bitmap-plus-plus 1.0.0

data/examples/draw_primitives.rb

@@ -0,0 +1,53 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Example: Drawing Primitives
+#
+# This example demonstrates the basic drawing capabilities of BitmapPlusPlus:
+# - Lines
+# - Rectangles (filled and outline)
+# - Triangles (filled and outline)
+# - Circles (filled and outline)
+
+require "bitmap-plus-plus"
+
+def draw_primitives
+  # Create a custom background color from hex value
+  background = Bmp::Pixel.new(0x25292e)
+
+  # Create a 512x240 bitmap
+  image = Bmp::Bitmap.new(512, 240)
+  image.clear(background)
+
+  # Draw a yellow line from position (250, 50) to position (500, 50)
+  image.draw_line(250, 50, 500, 50, Bmp::Yellow)
+
+  # Draw a red rectangle outline at position (10, 10) with size 100x100
+  image.draw_rect(10, 10, 100, 100, Bmp::Red)
+
+  # Draw a white filled rectangle at position (120, 10) with size 100x100
+  image.fill_rect(120, 10, 100, 100, Bmp::White)
+
+  # Draw a cyan triangle outline
+  image.draw_triangle(60, 120, 10, 220, 120, 220, Bmp::Cyan)
+
+  # Draw a magenta filled triangle
+  image.fill_triangle(180, 120, 130, 220, 245, 220, Bmp::Magenta)
+
+  # Draw a gray circle outline at center (300, 170) with radius 50
+  image.draw_circle(300, 170, 50, Bmp::Gray)
+
+  # Draw a lime filled circle at center (420, 170) with radius 50
+  image.fill_circle(420, 170, 50, Bmp::Lime)
+
+  # Save the bitmap
+  output_path = File.join(__dir__, "output", "primitives.bmp")
+  Dir.mkdir(File.dirname(output_path)) unless Dir.exist?(File.dirname(output_path))
+	std_path = Std::Filesystem::Path.new(output_path)
+  image.save(std_path)
+
+  puts "Saved: #{output_path}"
+  puts "Image size: #{image.width}x#{image.height}"
+end
+
+draw_primitives if __FILE__ == $PROGRAM_NAME

data/examples/julia.rb

@@ -0,0 +1,68 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Example: Julia Set Fractal
+#
+# This example generates a Julia set fractal image using BitmapPlusPlus.
+# The Julia set is similar to the Mandelbrot set but uses a fixed complex
+# constant instead of varying it per pixel.
+
+require "bitmap-plus-plus"
+require_relative "colormaps"
+
+MAX_ITERATIONS = 300
+
+# Julia set constant - try different values for different patterns!
+# Some interesting values:
+#   -0.70, 0.27015   (classic)
+#   -0.8, 0.156      (dendrite)
+#   -0.4, 0.6        (rabbit)
+#    0.285, 0.01     (siegel disk)
+CR = -0.70000
+CI = 0.27015
+
+def julia
+  width = 640
+  height = 480
+  image = Bmp::Bitmap.new(width, height)
+
+  puts "Generating Julia set (#{width}x#{height})..."
+  puts "Constant: #{CR} + #{CI}i"
+
+  height.times do |y|
+    puts "Row: #{y}/#{height}" if (y % 50).zero?
+
+    width.times do |x|
+      # Map pixel coordinates to complex plane
+      nextr = 1.5 * (2.0 * x / width - 1.0)
+      nexti = (2.0 * y / height - 1.0)
+
+      MAX_ITERATIONS.times do |i|
+        prevr = nextr
+        previ = nexti
+
+        # z = z^2 + c (where c is fixed)
+        nextr = prevr * prevr - previ * previ + CR
+        nexti = 2 * prevr * previ + CI
+
+        # Check if escaped
+        if (nextr * nextr + nexti * nexti) > 4
+          index = ((1000.0 * i) / MAX_ITERATIONS).floor
+          pixel = HSV_COLORMAP[index.clamp(0, HSV_COLORMAP.length - 1)]
+          image.set(x, y, pixel)
+          break
+        end
+      end
+    end
+  end
+
+  # Save the bitmap
+  output_path = File.join(__dir__, "output", "julia.bmp")
+  Dir.mkdir(File.dirname(output_path)) unless Dir.exist?(File.dirname(output_path))
+	std_path = Std::Filesystem::Path.new(output_path)
+  image.save(std_path)
+
+  puts "Saved: #{output_path}"
+end
+
+julia if __FILE__ == $PROGRAM_NAME

data/examples/mandelbrot.rb

@@ -0,0 +1,68 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Example: Mandelbrot Set Fractal
+#
+# This example generates a Mandelbrot set fractal image using BitmapPlusPlus.
+# It demonstrates:
+# - Creating bitmaps with specific dimensions
+# - Setting individual pixels with calculated colors
+# - Using color maps for smooth coloring
+
+require "bitmap-plus-plus"
+require_relative "colormaps"
+
+MAX_ITERATIONS = 500
+
+def mandelbrot
+  width = 640
+  height = 480
+  image = Bmp::Bitmap.new(width, height)
+
+  puts "Generating Mandelbrot set (#{width}x#{height})..."
+
+  height.times do |y|
+    puts "Row: #{y}/#{height}" if (y % 50).zero?
+
+    width.times do |x|
+      # Map pixel coordinates to complex plane
+      cr = 1.5 * (2.0 * x / width - 1.0) - 0.5
+      ci = (2.0 * y / height - 1.0)
+
+      nextr = nexti = 0.0
+
+      MAX_ITERATIONS.times do |i|
+        prevr = nextr
+        previ = nexti
+
+        # z = z^2 + c
+        nextr = prevr * prevr - previ * previ + cr
+        nexti = 2 * prevr * previ + ci
+
+        # Check if escaped (|z| > 2)
+        if (nextr * nextr + nexti * nexti) > 4
+          z = Math.sqrt(nextr * nextr + nexti * nexti)
+
+          # Smooth coloring using continuous iteration count
+          # https://en.wikipedia.org/wiki/Mandelbrot_set#Continuous_.28smooth.29_coloring
+          smooth_i = i + 1 - Math.log2(Math.log2(z))
+          index = (1000.0 * Math.log2(1.75 + smooth_i) / Math.log2(MAX_ITERATIONS)).to_i
+
+          pixel = JET_COLORMAP[index.clamp(0, JET_COLORMAP.length - 1)]
+          image.set(x, y, pixel)
+          break
+        end
+      end
+    end
+  end
+
+  # Save the bitmap
+  output_path = File.join(__dir__, "output", "mandelbrot.bmp")
+  Dir.mkdir(File.dirname(output_path)) unless Dir.exist?(File.dirname(output_path))
+	std_path = Std::Filesystem::Path.new(output_path)
+	image.save(std_path)
+
+  puts "Saved: #{output_path}"
+end
+
+mandelbrot if __FILE__ == $PROGRAM_NAME

data/examples/random_colors.rb

@@ -0,0 +1,37 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Example: Random Colors
+#
+# This example demonstrates:
+# - Using the each iterator to modify pixels
+# - Creating pixels with random RGB values
+# - The assign method for copying pixel values
+
+require "bitmap-plus-plus"
+
+def random_pixel
+  Bmp::Pixel.new(rand(256), rand(256), rand(256))
+end
+
+def random_colors
+  puts "Generating random color image..."
+
+  image = Bmp::Bitmap.new(512, 512)
+
+  # Use the each iterator to set each pixel to a random color
+  image.each do |pixel|
+    pixel.assign(random_pixel)
+  end
+
+  # Save the bitmap
+  output_path = File.join(__dir__, "output", "random_colors.bmp")
+  Dir.mkdir(File.dirname(output_path)) unless Dir.exist?(File.dirname(output_path))
+	std_path = Std::Filesystem::Path.new(output_path)
+  image.save(std_path)
+
+  puts "Saved: #{output_path}"
+  puts "Total pixels: #{image.size}"
+end
+
+random_colors if __FILE__ == $PROGRAM_NAME

data/examples/transformations.rb

@@ -0,0 +1,84 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Example: Image Transformations
+#
+# This example demonstrates the transformation methods:
+# - flip_v (vertical flip)
+# - flip_h (horizontal flip)
+# - rotate_90_left
+# - rotate_90_right
+#
+# All transformations return a new Bitmap (they are immutable operations).
+
+require "bitmap-plus-plus"
+
+def create_test_image
+  # Create an asymmetric image to clearly show transformations
+  image = Bmp::Bitmap.new(200, 150)
+  image.clear(Bmp::White)
+
+  # Draw an "F" shape to make orientation obvious
+  image.fill_rect(20, 20, 20, 110, Bmp::Blue)   # Vertical bar
+  image.fill_rect(40, 20, 80, 20, Bmp::Blue)    # Top horizontal
+  image.fill_rect(40, 60, 50, 20, Bmp::Blue)    # Middle horizontal
+
+  # Add a red circle in top-right corner
+  image.fill_circle(160, 40, 25, Bmp::Red)
+
+  image
+end
+
+def transformations
+  puts "Generating transformation examples..."
+
+  output_dir = File.join(__dir__, "output")
+  Dir.mkdir(output_dir) unless Dir.exist?(output_dir)
+
+  # Create original image
+  original = create_test_image
+	path = File.join(output_dir, "transform_original.bmp")
+	std_path = Std::Filesystem::Path.new(path)
+	original.save(std_path)
+
+	puts "Saved: transform_original.bmp (#{original.width}x#{original.height})"
+
+  # Vertical flip
+  flipped_v = original.flip_v
+	path = File.join(output_dir, "transform_flip_v.bmp")
+	std_path = Std::Filesystem::Path.new(path)
+	flipped_v.save(std_path)
+  puts "Saved: transform_flip_v.bmp"
+
+  # Horizontal flip
+  flipped_h = original.flip_h
+	path = File.join(output_dir, "transform_flip_h.bmp")
+	std_path = Std::Filesystem::Path.new(path)
+  flipped_h.save(std_path)
+  puts "Saved: transform_flip_h.bmp"
+
+  # Rotate 90 degrees left (counter-clockwise)
+  rotated_left = original.rotate_90_left
+	path = File.join(output_dir, "transform_rotate_left.bmp")
+	std_path = Std::Filesystem::Path.new(path)
+	rotated_left.save(std_path)
+  puts "Saved: transform_rotate_left.bmp (#{rotated_left.width}x#{rotated_left.height})"
+
+  # Rotate 90 degrees right (clockwise)
+  rotated_right = original.rotate_90_right
+	path = File.join(output_dir, "transform_rotate_right.bmp")
+	std_path = Std::Filesystem::Path.new(path)
+	rotated_right.save(std_path)
+  puts "Saved: transform_rotate_right.bmp (#{rotated_right.width}x#{rotated_right.height})"
+
+  # Chain transformations: flip both ways = 180 degree rotation
+  rotated_180 = original.flip_v.flip_h
+	path = File.join(output_dir, "transform_rotate_180.bmp")
+	std_path = Std::Filesystem::Path.new(path)
+	rotated_180.save(std_path)
+  puts "Saved: transform_rotate_180.bmp (flip_v + flip_h)"
+
+  puts "\nAll transformations complete!"
+end
+
+transformations if __FILE__ == $PROGRAM_NAME