gene 0.0.1 → 0.1.0

data/lib/generator.rb

@@ -0,0 +1,83 @@
+class Generator < Dsl
+  include Aligner
+  
+  DEFAULT_XOVER_FREQ    = 0.1
+  DEFAULT_MUTATION_FREQ = 0.25
+  
+  attr_accessor :current_sequence
+  attr_reader   :cells, :gene_map, :fitness_map, :xover_freq, :mutation_freq
+  
+  def initialize(cell_1, cell_2)
+    @cells = (@cell_1, @cell_2 = cell_1, cell_2)
+    
+    @gene_map         = align_cells
+    @fitness_map      = cells.map(&:fitness)
+    @current_sequence = rand(2)
+    super
+  end
+  
+  def combine
+    Cell.new(&configuration)
+  end
+  
+  private
+  
+  def finish_init
+    @xover_freq    ||= DEFAULT_XOVER_FREQ
+    @mutation_freq ||= DEFAULT_MUTATION_FREQ
+  end
+  
+  def align_cells
+    alignment_for = align_crossover
+
+    [
+      @cell_1.genes_from_alignment_map(alignment_for[:cell_1]),
+      @cell_2.genes_from_alignment_map(alignment_for[:cell_2])
+    ]
+  end
+  
+  def configuration
+    lambda do
+      num_genes.times.each do |index|
+        send(:"gene_#{index}", &new_gene_from(gene_map[read_sequence][index]))
+      end
+    end
+  end
+  
+  def new_gene_from(model_gene)
+    lambda do
+      num_points.times.each do |index|
+        [:x, :y].each do |axis| 
+          send(:"point_#{index}_#{axis}", &new_trait_from(model_gene.polygon.points[index].send(axis)))
+        end
+      end
+
+      model_gene.color.each_pair do |channel, model_trait|
+        send(:"trait_#{channel}", &new_trait_from(model_trait))
+      end
+    end
+  end
+  
+  def new_trait_from(model_trait)
+    lambda do
+      set_value mutate(model_trait)
+      deviate_from fitness_map[current_sequence]
+    end
+  end
+  
+  def mutate(trait)
+    rand(0) < mutation_freq ? trait.mutated_value : trait.value
+  end
+  
+  def read_sequence
+    rand(0) < xover_freq ? self.current_sequence ^= 1 : current_sequence
+  end
+  
+  def method_missing(name, *args, &block)
+    case name.to_s
+    when "set_xover_freq":    @xover_freq    = args.first
+    when "set_mutation_freq": @mutation_freq = args.first
+    else super
+    end
+  end
+end

data/lib/geometry.rb

@@ -0,0 +1,64 @@
+module Geometry    
+  def hulled_sequence
+    format_points_in(hull)
+  end
+  
+  private
+  
+  def hull
+    ensure_hullable_with(polygon)
+
+    list_of_points = polygon.sort_by { |point| point.x.value }
+    left_point     = list_of_points.shift
+    right_point    = list_of_points.pop
+    determinant    = determinant_function(left_point, right_point)
+
+    lower_list, upper_list = [left_point], [left_point]
+    lower_hull, upper_hull = [], []
+
+    partition_points_from(list_of_points, lower_list, upper_list, determinant)
+
+    trim_hull(lower_hull, lower_list << right_point, true)
+    trim_hull(upper_hull, upper_list << right_point, false)
+
+    lower_hull + upper_hull.reverse[1..-2]
+  end
+  
+  def ensure_hullable_with(points)
+    assert_at_least 3, points.length, "Can not calculate the convex hull unless there are at least 3 points (#{points.size} #{points.size == 1 ? 'was' : 'were'} provided)"
+  end
+  
+  def partition_points_from(list_of_points, lower_list, upper_list, determinant_lambda)
+    until list_of_points.empty?
+      point = list_of_points.shift
+      (determinant_lambda[point] < 0 ? lower_list : upper_list) << point
+    end
+  end
+  
+  def trim_hull(hull, list, xor_boolean)
+    until list.empty?
+      hull << list.shift
+      while hull.size >= 3 && !convex?(hull.last(3), xor_boolean)
+        hull[-2] = hull[-1]
+        hull.pop
+      end
+    end
+  end
+
+  def determinant_function(point_1, point_2)
+    # This is a good candidate for functionals.rb apply_head.
+    lambda { |pivot| multiply_difference(point_1, point_2, pivot) - multiply_difference(pivot, point_2, point_1) }
+  end
+  
+  def multiply_difference(point_1, point_2, point_3)
+    (point_1.x.value - point_2.x.value) * (point_3.y.value - point_2.y.value)
+  end
+
+  def convex?(points, xor_boolean)
+    (determinant_function(points[0], points[2])[points[1]] > 0) ^ xor_boolean
+  end
+  
+  def format_points_in(array)
+    array.inject([]) { |list, point| list << point.x.value << point.y.value }
+  end
+end

data/lib/hungarian.rb

@@ -0,0 +1,205 @@
+# Written by: Evan Senter
+#
+# - - - - - U S A G E - - - - -
+#
+# hungarian = Hungarian.new(matrix_to_solve)
+# solution  = hungarian.solve
+#
+# ...or...
+#
+# hungarian = Hungarian.new
+# solution  = hungarian.solve(matrix_to_solve)
+# 
+# The method solve returns an array of cell locations such that the assignment problem is solved.
+# See http://en.wikipedia.org/wiki/Hungarian_algorithm for more information on this problem.
+#
+# Adapted from: http://www.public.iastate.edu/~ddoty/HungarianAlgorithm.html
+
+class Hungarian
+  EMPTY = 0
+  STAR  = 1
+  PRIME = 2
+  
+  def initialize(matrix = nil); setup(matrix) if matrix; end
+    
+  def solve(matrix = nil)
+    setup(matrix) if matrix
+    raise(ArgumentError, "You must provide a matrix to solve.") unless @matrix
+    
+    method = :minimize_rows
+    while method != :finished
+      method = self.send(*method)
+    end
+    
+    return assignment
+  end
+  
+  private
+  
+  # - - - - - M A I N   S U B M E T H O D S - - - - -
+  
+  def minimize_rows
+    # For each row of the matrix, find the smallest element and subtract it from every element in its row.
+    
+    @matrix.map! do |row|
+      min_value = row.min
+      row.map { |element| element - min_value }
+    end
+    
+    return :star_zeroes
+  end
+  
+  def star_zeroes
+    # Find a zero (Z) in the resulting matrix. If there is no starred zero in its row or column, star Z. Repeat for each element in the matrix.
+    
+    traverse_indices do |row, column|
+      if @matrix[row][column].zero? && !location_covered?(row, column)
+        @mask[row][column] = STAR
+        cover_cell(row, column)
+      end
+    end
+    reset_covered_hash
+    
+    return :mask_columns
+  end
+  
+  def mask_columns
+    # Cover each column containing a starred zero. If all columns are covered, the starred zeros describe a complete set of unique assignments.
+    
+    index_range.each do |index|
+      @covered[:columns][index] = true if column_mask_values_for(index).any? { |value| value == STAR }
+    end
+    
+    return @covered[:columns].all? ? :finished : :prime_zeroes
+  end
+  
+  def prime_zeroes
+    # Find a noncovered zero and prime it. If there is no starred zero in the row containing this primed zero, call augment_path.
+    # Otherwise, cover this row and uncover the column containing the starred zero. Continue in this manner until there are no uncovered zeros left
+    # and call adjust_matrix.
+    
+    while (row, column = find_uncovered_zero) != [-1, -1]
+      @mask[row][column] = PRIME
+      
+      if star_loc_in_row = row_mask_values_for(row).index(STAR)
+        @covered[:rows][row] = true
+        @covered[:columns][star_loc_in_row] = false
+      else
+        return :augment_path, row, column
+      end
+    end
+    
+    return :adjust_matrix
+  end
+  
+  def augment_path(starting_row, starting_column) 
+    # Construct a series of alternating primed and starred zeroes. Let Z0 represent the uncovered primed zero passed in.
+    # Let Z1 denote the starred zero in the column of Z0 (if any). Let Z2 denote the primed zero in the row of Z1 (there will always be one).
+    # Continue until the series terminates at a primed zero that has no starred zero in its column. Unstar each starred zero of the series, 
+    # star each primed zero of the series, erase all primes and uncover every line in the matrix, and call mask_columns.
+    
+    path = [[starting_row, starting_column]]
+    path.instance_eval do
+      def previous_row;    self.last[0]; end
+      def previous_column; self.last[1]; end
+    end
+    
+    loop do
+      if row_containing_star = column_mask_values_for(path.previous_column).index(STAR)
+        path << [row_containing_star, path.previous_column]
+      else
+        break
+      end
+      
+      col_containing_prime = row_mask_values_for(path.previous_row).index(PRIME)
+      path << [path.previous_row, col_containing_prime]
+    end
+    
+    update_elements_in(path)
+    traverse_indices { |row, column| @mask[row][column] = EMPTY if @mask[row][column] == PRIME }
+    reset_covered_hash
+    
+    return :mask_columns
+  end
+  
+  def adjust_matrix
+    # Add the smallest value to every element of each covered row, subtract it from every element of each uncovered column, and call prime_zeroes.
+    
+    smallest_value = nil
+    traverse_indices do |row, column| 
+      if !location_covered?(row, column) && (smallest_value.nil? || @matrix[row][column] < smallest_value)
+        smallest_value = @matrix[row][column]
+      end
+    end
+    
+    indices_of_covered_rows.each { |index| @matrix[index].map! { |value| value + smallest_value } }
+
+    covered_columns = indices_of_uncovered_columns
+    index_range.each { |row| covered_columns.each { |column| @matrix[row][column] -= smallest_value } }
+    
+    return :prime_zeroes
+  end
+  
+  # - - - - - H E L P E R   M E T H O D S - - - - -
+  
+  def setup(matrix)
+    @matrix  = matrix
+    @length  = @matrix.length
+    @mask    = Array.new(@length) { Array.new(@length, EMPTY) }                               # 2D array of constants (listed above)
+    @covered = { :rows => Array.new(@length, false), :columns => Array.new(@length, false) }  # Boolean arrays
+  end
+  
+  def assignment
+    index_range.inject([]) { |path, row_index| path << [row_index, @mask[row_index].index(STAR)] }
+  end
+  
+  def update_elements_in(path)    
+    path.each do |cell|
+      @mask[cell[0]][cell[1]] = case @mask[cell[0]][cell[1]]
+      when STAR  then EMPTY
+      when PRIME then STAR
+      end
+    end
+  end
+  
+  def find_uncovered_zero
+    traverse_indices do |row, column|
+      return [row, column] if @matrix[row][column].zero? && !location_covered?(row, column)
+    end
+    [-1, -1]
+  end
+  
+  def cover_cell(row, column)
+    @covered[:rows][row] = @covered[:columns][column] = true
+  end
+  
+  def reset_covered_hash
+    @covered.values.each { |cover| cover.fill(false) }
+  end
+  
+  def location_covered?(row, column)
+    @covered[:rows][row] || @covered[:columns][column]
+  end
+  
+  def row_mask_values_for(row)
+    index_range.map { |column| @mask[row][column] }
+  end
+  
+  def column_mask_values_for(column)
+    index_range.map { |row| @mask[row][column] }
+  end
+  
+  def indices_of_covered_rows
+    index_range.select { |index| @covered[:rows][index] }
+  end
+    
+  def indices_of_uncovered_columns
+    index_range.select { |index| !@covered[:columns][index] }
+  end
+  
+  def traverse_indices(&block)
+    index_range.each { |row| index_range.each { |column| yield row, column } }
+  end
+  
+  def index_range; 0...@length; end
+end

data/lib/imagine.rb

@@ -0,0 +1,22 @@
+module Imagine
+  def compare_image_to(image)
+    # http://en.wikipedia.org/wiki/RMSD
+    aggregate_deviation = 0.0
+    
+    target_image.each_pixel do |target_pixel, x, y|      
+      aggregate_deviation += compare_pixels(target_pixel, image.pixel_color(x, y))
+    end
+    
+    1 - Math.sqrt(aggregate_deviation / (Magick::MaxRGB ** 2 * image_dimensions.x * image_dimensions.y * 3))
+  end
+  
+  private
+  
+  def compare_pixels(target_pixel, actual_pixel)
+    [:red, :green, :blue].inject(0.0) { |distance, channel| distance + compare_channel(channel, target_pixel, actual_pixel) }
+  end
+  
+  def compare_channel(name, target_pixel, actual_pixel)
+    (target_pixel.send(name) - actual_pixel.send(name)) ** 2
+  end
+end

data/lib/petri.rb

@@ -0,0 +1,85 @@
+class Petri < Dsl
+  include Imagine
+  
+  attr_reader :round, :target_image, :dish
+  
+  def initialize(image_path)
+    @round = 0
+    prepare_image_at(image_path)
+    super
+  end
+  
+  def evolve
+    top_k = dish[0, dish.length / 3 * 2]
+    @dish = (top_k + (dish.length - top_k.length).times.inject([]) do |new_cells, index|
+      new_cells << Generator.new(top_k[rand(top_k.length)], top_k[rand(top_k.length)]).combine
+    end)
+    
+    calculate_fitnesses
+    sort_by_fitness!
+    
+    if (round % 100).zero?
+      dish.first.image.write("#{round}.png")
+      puts dish.first.genes.map { |gene| "[" + gene.polygon.map { |point| "#{point.x.value}, #{point.y.value}" }.join(", ") + "]" }.join(", ")
+      puts "Fitness: #{dish.first.fitness}"
+    end
+    
+    next_round
+  end
+  
+  private
+  
+  def prepare_image_at(image_path)
+    @target_image = Magick::Image.read(image_path).first
+    set_parameter(:image_dimensions, Point.new(target_image.columns, target_image.rows))
+  end
+  
+  def finish_init
+    set_parameter(:num_cells,  6) unless self.class.respond_to?(:num_cells)
+    set_parameter(:num_genes,  3) unless self.class.respond_to?(:num_genes)
+    set_parameter(:num_points, 4) unless self.class.respond_to?(:num_points)
+    
+    fill_out_cells
+    calculate_fitnesses
+    sort_by_fitness!
+  end
+  
+  def fill_out_cells
+    @dish = num_cells.times.map { Cell.new }
+  end
+  
+  def calculate_fitnesses
+    dish.each do |cell|
+      cell.fitness ||= compare_image_to(cell.image)
+    end
+  end
+  
+  def sort_by_fitness!
+    dish.sort! { |a, b| b.fitness <=> a.fitness }
+  end
+  
+  def next_round
+    @round += 1
+  end
+  
+  def set_num_cells(desired)
+    set_parameter(:num_cells, (desired % 3) == 0 ? desired : desired + 3 - (desired % 3))
+  end
+  
+  def set_parameter(name, value)
+    name = name.to_s.gsub(/^set_/, "")
+    
+    class_metaclass.instance_eval do
+      attr_reader name
+    end
+    
+    self.class.instance_variable_set(:"@#{name}", value)
+  end
+  
+  def method_missing(name, *args, &block) 
+    case name
+    when :set_num_genes, :set_num_points: set_parameter(name, args.first)
+    else super
+    end
+  end
+end