open-ship 0.1 → 0.1.2

data/CHANGELOG

@@ -1 +1,3 @@
+v0.1.2. added classes for sorting shipments
+v0.1.1. changed base filenames for less painful requires
 v0.1. first version

data/Manifest

@@ -3,9 +3,20 @@ LICENSE
 Manifest
 README
 Rakefile
-lib/openship.rb
-lib/openship/label.rb
-lib/openship/openship.rb
-lib/openship/sscc.rb
-spec/openship/sscc_spec.rb
+lib/open-ship.rb
+lib/open-ship/gga4r.rb
+lib/open-ship/gga4r/array_helper.rb
+lib/open-ship/gga4r/gga4r_main.rb
+lib/open-ship/gga4r/version.rb
+lib/open-ship/label.rb
+lib/open-ship/label/carton_label.rb
+lib/open-ship/label/text_label.rb
+lib/open-ship/sortr.rb
+lib/open-ship/sscc.rb
+spec/open-ship/carton_spec.rb
+spec/open-ship/label/carton_label_spec.rb
+spec/open-ship/label/text_label_spec.rb
+spec/open-ship/sscc_spec.rb
 spec/spec_helper.rb
+tmp/test_carton_label.pdf
+tmp/test_text_label.pdf

data/lib/open-ship/gga4r/array_helper.rb

@@ -0,0 +1,30 @@
+class Array
+  
+  
+  # Yields given bloc using arrays items pair by pair.
+  # e.g.
+  # <code>
+  # ["a","b","c","d"].each_pair do |first, second|
+  #  puts second + " - " + second
+  # end
+  # </code>
+  # will print:
+  # b - a
+  # c - d
+  # 
+  def each_pair
+    num = self.size/2
+    (0..num-1).collect do |index|
+      yield self[index*2], self[(index*2)+1]
+    end
+  end
+  
+  # Splits the array into two parts first from position
+  # 0 to "position" and second from position "position+1" to
+  # last position.
+  # Returns two new arrays.
+  def separate(position)
+   return self[0..position], self[position+1..-1]
+  end
+  
+end

data/lib/open-ship/gga4r/gga4r_main.rb

@@ -0,0 +1,180 @@
+require "yaml"
+require "logger"
+require "rubygems"
+require "active_support"
+
+class GeneticAlgorithm
+  attr_reader :generations, :p_combination, :p_mutation
+  
+  # Must be initialized with a Array of chromosomes
+  # To be a chomosome the object must implement the next methods:
+  #  - fitness
+  #  - recombine
+  #  - mutate
+  #  Accepts the next properties:
+  #   - extra_generations: adds given array of generations to the GeneticAlgorithm's own array of generations.
+  #   - p_combination: probability of combiantion ( by default 0.2 )
+  #   - p_mutation: probability of mutation ( by default 0.01 )
+  #   - max_population: maximum number of individuals that are allowed to form a generation.
+  #   - logger: logger to write messages if given.
+  def initialize(in_pop, prop = {})    
+    @generations = [in_pop]
+    @generations += prop[:extra_generations] if prop[:extra_generations]
+    @p_combination = prop[:p_combination] || 0.2
+    @p_mutation = prop[:p_mutation] || 0.01
+    @max_population =  prop[:max_population]
+    @logger = prop[:logger] if prop[:logger]
+    @use_threads = prop[:use_threads] if prop[:use_threads]
+#    mean_fitness
+  end
+
+
+# HELPER METHODS
+
+  # Returns the number of generations that are in the GeneticAlgorithm object.
+  def num_generations
+    @generations.size - 1
+  end
+
+  # Returns an array with the best fitted individuals for given
+  # generation number ( by default from last generation ).
+  def best_fit(num_generation = -1)
+    raise "Generation not generated still num generations = #{num_generations}" if num_generation > num_generations  
+    generation = @generations[num_generation]
+    max_fitness = generation.collect { |chromosome| chromosome.fitness }.max
+    generation.select { |chromosome| chromosome.fitness == max_fitness }
+  end
+  
+  # Returns the mean of the fitness for given
+  # generation number ( by default from last generation ).
+  def mean_fitness(num = -1)
+    raise "Generation not generated still num generations = #{num_generations}" if num > self.num_generations
+    num = self.num_generations if num == -1
+    sum_fitness = 0
+    @generations[num].each { |chromosome| sum_fitness += chromosome.fitness }
+    sum_fitness.to_f / @generations[num].size.to_f
+  end
+
+  # Returns a GeneticAlgorithm object with the generations
+  # loaded from given files and with properties prop.
+  # Files must contain the chromosomes in YAML format.
+  def self.populate_from_files(a_filenames, prop = {})
+    a_filenames = [a_filenames] if a_filenames.class == String
+    
+    loaded_generations = a_filenames.collect { |filename| YAML.load(File.open(filename, "r")) }
+    prop[:extra_generations] = loaded_generations[1..-1] if loaded_generations.size > 1
+    return GeneticAlgorithm.new(loaded_generations[0], prop)
+  end
+
+  # Saves into filename and in yaml format the generation that matchs with given
+  # generation number ( by default from last generation ).
+  def save_generation(filename, num_generation = -1)
+    f = File.new(filename, "w")
+    f.write(self.generations[num_generation].to_yaml)
+    f.close    
+  end
+
+# EVOLUTION METHODS
+
+  # Evolves the actual generation num_steps steps (1 by default).
+  def evolve(num_steps = 1)
+    num_steps.times do
+      @generations << evaluation_with_threads(@generations[-1])
+      selection!
+      recombination! 
+      mutation!
+    end
+  end
+  
+  # Prepares given generation for evaluation ( evaluates its fitness ).
+  def evaluation(g)
+    @logger.debug "Evaluation " + g.size.to_s + " chromosomes." if @logger
+    i = 0
+    g.collect do |chromosome|
+      i += 1
+      @logger.debug "Evaluating chromosome #{i}:" if @logger
+      @logger.debug "#{chromosome.stats.join("\n")}" if @logger
+      chromosome.fitness
+      chromosome
+    end
+  end
+
+  # Prepares given generation for evaluation ( evaluates its fitness ),
+  # using Threads
+  def evaluation_with_threads(g)
+    @logger.debug "Evaluation " + g.size.to_s + " chromosomes." if @logger
+    threads = []
+    i = 0
+    g.each do |chromosome|
+      i += 1
+      @logger.debug "Evaluating chromosome #{i}:" if @logger
+      @logger.debug "#{chromosome.stats.join("\n")}" if @logger
+      threads << Thread.new(chromosome) do |t_chromosome|
+        t_chromosome.fitness
+        @logger.debug "Thread finished #{Thread.current.object_id} - #{Thread.current.status}" if @logger
+      end
+    end
+    # Wait for threads for finish
+		threads.each do |thread|
+			@logger.debug "#{thread.status}" if @logger
+			thread.join
+			@logger.debug "#{thread.status}" if @logger
+		end
+    return g
+  end
+
+  
+  # Selects population to survive and recombine
+  def selection(g)
+    g_tmp = remainder_stochastic_sampling(g)
+    g_tmp = g_tmp.sort_by {|i| -i.fitness }[0..(@max_population-1)] if @max_population && (g_tmp.size > @max_population)
+    g_tmp
+  end
+  def selection!; @generations[-1] = selection(@generations[-1]); end
+
+  # Recombines population  
+  def recombination(g)
+    @logger.debug "Recombination " + g.size.to_s + " chromosomes." if @logger
+    new_generation = g.dup.shuffle!
+    @logger.debug "Shuffled!" if @logger
+    new_children = []
+    new_generation.in_groups_of(2) do |chromosome1, chromosome2|
+      next if chromosome2.nil?
+      if rand > (1 - @p_combination)
+        @logger.debug "Recombining" if @logger
+        new_children << chromosome1.recombine(chromosome2)
+      end
+    end
+    new_generation + new_children    
+  end
+
+  def recombination!; @generations[-1] = recombination(@generations[-1]); end
+
+  # Mutates population
+  def mutation(g)
+    @logger.debug "Mutation " + g.size.to_s + " chromosomes." if @logger  
+    new_generation = g.dup
+    new_generation.each do |chromosome|
+      if rand > (1 - @p_mutation)
+        @logger.debug "Mutate" if @logger
+        chromosome.mutate 
+      end
+    end
+  end
+  def mutation!; @generations[-1] = mutation(@generations[-1]); end
+  
+  # Remainder Stochastic Sampling algorithm for selection.
+  def remainder_stochastic_sampling(g)
+    new_generation = []
+    g.each do |chromosome|
+      num_rep = 0
+      if chromosome.fitness > 0
+        num_rep += (chromosome.fitness.to_f/mean_fitness).to_i
+        num_rep += 1 if rand > (1 - (chromosome.fitness/mean_fitness)%1)
+      end
+      new_generation = new_generation + ([chromosome] * num_rep)
+    end
+    new_generation
+  end
+
+end

data/lib/open-ship/gga4r/version.rb

@@ -0,0 +1,9 @@
+module Gga4r #:nodoc:
+  module VERSION #:nodoc:
+    MAJOR = 0
+    MINOR = 9
+    TINY  = 2
+
+    STRING = [MAJOR, MINOR, TINY].join('.')
+  end
+end

data/lib/open-ship/gga4r.rb

@@ -0,0 +1 @@
+Dir[File.join(File.dirname(__FILE__), 'gga4r/**/*.rb')].sort.each { |lib| require lib }

data/lib/open-ship/label/carton_label.rb

@@ -0,0 +1,61 @@
+require 'prawn'
+require 'prawn/measurement_extensions'
+require 'barby'
+require 'barby/outputter/prawn_outputter'
+
+module OpenShip
+  module Label
+
+    class CartonLabel
+
+      attr_accessor :product, :style, :sku, :upc, :quantity, :origin
+
+      def gtin
+        self.upc.to_s.rjust(14, "0")
+      end
+
+      def to_pdf
+        document = Prawn::Document.new(:page_size   => [11.cm, 6.7.cm],
+          :right_margin => 0.0.cm,
+          :left_margin => 0.0.cm,
+          :top_margin => 0.0.cm,
+          :bottom_margin => 0.0.cm,
+          :page_layout => :portrait)
+
+        barcode = Barby::Code25Interleaved.new(self.gtin)
+
+        barcode.annotate_pdf(document, {:x => 0.5.cm, :y => 1.7.cm, :xdim => 0.073.cm, :height => 2.5.cm})
+
+        document.stroke do
+          document.rectangle [0.5.cm,6.4.cm], 1.5.cm, 1.5.cm
+        end
+
+
+        document.text_box("QTY", :size => 16, :align => :center, :at => [0.5.cm, 6.3.cm], :width => 1.5.cm, :height => 1.cm)
+        document.text_box(self.quantity.to_s, :size => 20, :align => :center, :at => [0.5.cm, 5.7.cm], :width => 1.5.cm, :height => 1.5.cm)
+
+
+        document.text_box(self.gtin[0..7], :size => 16, :align => :left, :at => [2.2.cm, 6.3.cm], :width => 2.cm, :height => 1.cm)
+        document.text_box(self.gtin[8..12], :size => 20, :align => :left, :at => [2.2.cm, 5.7.cm], :width => 2.5.cm, :height => 1.5.cm)
+
+        document.text_box(self.product, :size => 12, :align => :right, :at => [5.5.cm, 6.4.cm], :width => 5.cm, :height => 0.5.cm)
+        document.text_box(self.style, :size => 12, :align => :right, :at => [5.5.cm, 5.9.cm], :width => 5.cm, :height => 0.5.cm)
+        document.text_box(self.sku, :size => 12, :align => :right, :at => [5.5.cm, 5.4.cm], :width => 5.cm, :height => 0.5.cm)
+
+        document.text_box(self.origin, :size => 10, :align => :center, :at => [0.cm, 0.75.cm], :width => 11.cm, :height => 0.5.cm)
+
+        document.font("Courier")
+
+        document.text_box(self.gtin[0..0], :size => 16, :align => :left, :at => [1.25.cm, 1.5.cm], :width => 0.8.cm, :height => 1.cm)
+        document.text_box(self.gtin[1..2], :size => 16, :align => :left, :at => [2.3.cm, 1.5.cm], :width => 1.cm, :height => 1.cm)
+        document.text_box(self.gtin[3..7], :size => 16, :align => :left, :at => [3.7.cm, 1.5.cm], :width => 2.cm, :height => 1.cm)
+        document.text_box(self.gtin[8..12], :size => 16, :align => :left, :at => [6.45.cm, 1.5.cm], :width => 2.cm, :height => 1.cm)
+        document.text_box(self.gtin[13..13], :size => 16, :align => :left, :at => [9.15.cm, 1.5.cm], :width => 1.cm, :height => 1.cm)
+
+        document
+      end
+
+    end
+
+  end
+end

data/lib/open-ship/label/text_label.rb

@@ -0,0 +1,51 @@
+require 'prawn'
+require 'prawn/measurement_extensions'
+require 'barby'
+require 'barby/outputter/prawn_outputter'
+
+module OpenShip
+  module Label
+
+    class TextLabel
+
+      attr_accessor :address1, :address2, :address3, :address4,
+        :sku, :po, :line, :quantity, :total_cartons
+
+      def to_pdf
+        document = Prawn::Document.new(:page_size   => [20.cm, 15.cm],
+          :page_layout => :portrait)
+
+
+        document.text_box(self.address1, :size => 16, :align => :left, :at => [0.2.cm, 11.cm], :width => 12.cm, :height => 0.75.cm)
+        document.text_box(self.address2, :size => 16, :align => :left, :at => [0.2.cm, 10.25.cm], :width => 12.cm, :height => 0.75.cm)
+        document.text_box(self.address3, :size => 16, :align => :left, :at => [0.2.cm, 9.5.cm], :width => 12.cm, :height => 0.75.cm)
+        document.text_box(self.address4, :size => 16, :align => :left, :at => [0.2.cm, 8.75.cm], :width => 12.cm, :height => 0.75.cm)
+
+
+        po_line = "PO#: #{self.po}"
+        document.text_box(po_line, :size => 16, :align => :left, :at => [0.2.cm, 7.25.cm], :width => 12.cm, :height => 0.75.cm)
+
+        line_no = "Line #: #{self.line}"
+        document.text_box(line_no, :size => 16, :align => :left, :at => [0.2.cm, 6.5.cm], :width => 12.cm, :height => 0.75.cm)
+
+        style_line = "Mfg Style #: #{self.sku}"
+        document.text_box(style_line, :size => 16, :align => :left, :at => [0.2.cm, 5.75.cm], :width => 12.cm, :height => 0.75.cm)
+
+        quantity_line = "Inner Pk Qty: #{self.quantity}"
+        document.text_box(quantity_line, :size => 16, :align => :left, :at => [0.2.cm, 5.cm], :width => 12.cm, :height => 0.75.cm)
+
+        total_cartons_line = "Total Master Pk. Cartons per Line Item: #{self.total_cartons}"
+        document.text_box(total_cartons_line, :size => 16, :align => :left, :at => [0.2.cm, 4.25.cm], :width => 15.cm, :height => 0.75.cm)
+
+
+        document.text_box("Pre-Priced: NO", :size => 20, :align => :left, :at => [0.2.cm, 3.cm], :width => 12.cm, :height => 1.cm)
+        document.text_box("FRAGILE: NO", :size => 20, :align => :left, :at => [0.2.cm, 2.cm], :width => 12.cm, :height => 1.cm)
+
+
+        document
+      end
+
+    end
+
+  end
+end

data/lib/{openship → open-ship}/label.rb

@@ -1,6 +1,6 @@
 module OpenShip
 
-  class Label
+  module Label
 
   end
 

data/lib/open-ship/sortr.rb

@@ -0,0 +1,279 @@
+require "activesupport"
+
+module OpenShip
+  
+
+
+  class BoxPosition
+    attr_accessor :position, :box
+
+    def get_relative_space
+      self.box.get_space(:relative_position => self.position)
+    end
+
+  end
+
+  class Position
+
+    attr_accessor :x, :y, :z
+
+  end
+
+  class Box
+    attr_accessor :length, :width, :height, :label, :weight, :product_quantity
+
+    def volume
+      (length * width * height)
+    end
+
+
+
+  end
+
+  class Carton < Box
+    attr_accessor :margin, :box_positions, :width_margin, :length_margin
+
+    def initialize()
+      self.box_positions = []
+    end
+
+    @last_box = nil
+    
+    def space_packed(pos)
+      packed = false
+      self.box_positions.each { |bp|
+        unless packed
+          if ((pos.x >= bp.position.x) && (pos.x < (bp.box.width + bp.position.x)))
+            if ((pos.y >= bp.position.y) && (pos.y < (bp.box.length + bp.position.y)))
+              if ((pos.z >= bp.position.z) && (pos.z < (bp.box.height + bp.position.z)))
+                packed = true
+              end
+            end
+          end
+        end
+      }
+      packed
+    end
+
+    def get_space(opts={})
+      space = []
+      z_pos = 0
+      while (z_pos < self.height)
+        y_pos = 0
+        while(y_pos < self.length)
+          x_pos = 0
+          while(x_pos < self.width)
+            pos = Position.new
+            pos.x = x_pos
+            pos.y = y_pos
+            pos.z = z_pos
+            unless self.space_packed(pos)
+              space << pos
+            end
+            x_pos += 1
+          end
+          y_pos += 1
+        end
+        z_pos += 1
+      end
+      space
+    end
+
+    def free_space
+      self.volume - (self.box_positions.collect { |bp| bp.box }.sum { |bx| bx.volume })
+    end
+
+    def position_for_box(box)
+      spot = nil
+      free_space = self.get_space
+      free_space.each { |sp|
+        if ((self.width - sp.x) >= box.width)
+          if ((self.length - sp.y) >= box.length)
+            if ((self.height - sp.z) >= box.height)
+              # Test for potential overlaps
+              overlap = false
+              self.box_positions.each { |bp|
+
+                if ( ((bp.position.x + bp.box.width) > sp.x) && ((sp.x + box.width) > bp.position.x) )
+                  if ( ((bp.position.z + bp.box.height) > sp.z) && ((sp.z + box.height) > bp.position.z) )
+                    if ( ((bp.position.y + bp.box.length) > sp.y) && ((sp.y + box.length) > bp.position.y) )
+                      overlap = true;
+                      break
+                    end
+                  end
+                end
+              }
+              unless overlap
+                spot = sp
+                break
+              end
+            end
+          end
+        end
+      }
+      spot
+    end
+
+    def add_box(box)
+      if box.volume > self.free_space
+        return nil
+      end
+      pos = self.position_for_box(box)
+      if pos
+        bp = OpenShip::BoxPosition.new
+        bp.box = box
+        bp.position = pos
+        self.box_positions << bp
+      end
+      pos
+    end
+
+
+
+  end
+
+  class OpenShip::Shipment
+
+    @@fitness_values = []
+
+
+    attr_accessor :boxes_to_stores, :cartons_to_stores, :logger, :carton_dispenser
+
+    class CartonDispenser
+
+      def get_carton
+        cart = OpenShip::Carton.new
+        cart.width = 20
+        cart.height = 20
+        cart.length = 10
+        cart
+      end
+
+    end
+
+    def initialize(opts = {})
+      if opts[:logger]
+        @logger = opts[:logger]
+      else
+        @logger = Logger.new(STDOUT)
+        @logger.level = Logger::WARN
+      end
+      if opts[:carton_dispenser]
+        @carton_dispenser = opts[:carton_dispenser]
+      else
+        @carton_dispenser = CartonDispenser.new
+      end
+      @cartons_to_stores = nil
+      @boxes_to_stores = {}
+    end
+
+    def calculate_cartons
+      @cartons_to_stores = {}
+      self.boxes_to_stores.each { |k, v|
+        @cartons_to_stores[k] ||= []
+        cart = @carton_dispenser.get_carton
+        @cartons_to_stores[k] << cart
+        v.each { |box|
+          pos = cart.add_box(box)
+          if pos.nil?
+            cart = @carton_dispenser.get_carton
+            @cartons_to_stores[k] << cart
+            pos = cart.add_box(box)
+            if pos.nil?
+              raise "Box is too big for carton."
+            end
+          end
+        }
+      }
+      @cartons_to_stores
+    end
+
+    def fitness
+
+      if @cartons_to_stores.nil?
+        self.calculate_cartons
+      end
+
+      free_space = self.cartons_to_stores.sum { |k, v| v.sum { |c| c.free_space } }
+      box_count = self.boxes_to_stores.sum { |k, v| v.count }
+      carton_count = self.cartons_to_stores.sum { |k, v| v.count }
+      @logger.debug "Box Count: " + box_count.to_s
+      @logger.debug "Carton Free Space: " + free_space.to_s
+      @logger.debug "Carton Count: " + carton_count.to_s
+      fitness = (box_count.to_f / carton_count.to_f)
+      @@fitness_values << fitness
+      @logger.debug "Fitness Mean: " + fitness_mean.to_s
+      @logger.debug "Fitness: " + fitness.to_s
+      fitness
+    end
+
+    def stats
+      ["Total Volume :" + self.boxes_to_stores.sum { |k, v| v.sum { |b| b.volume } }.to_s]
+    end
+
+
+    def recombine(c2)
+      return1 = self.clone
+      return2 = c2.clone
+      self.boxes_to_stores.each { |k, v|
+        bxs = c2.boxes_to_stores[k]
+
+        cross_point = (rand * bxs.size).to_i
+        c1_a, c1_b = v.separate(cross_point)
+        c2_a, c2_b = bxs.separate(cross_point)
+        return1.boxes_to_stores[k] = c1_a + c2_b
+        return2.boxes_to_stores[k] = c2_a + c1_b
+      }
+      return1.cartons_to_stores = nil
+      return2.cartons_to_stores = nil
+      return1
+    end
+
+    def fitness_mean
+      (@@fitness_values.sum { |f| f } / @@fitness_values.length)
+    end
+
+    def mutate
+      #if (self.fitness < self.fitness_mean)
+        @logger.debug "################ Making a mutation!"
+        self.boxes_to_stores.each { |k, v|
+          self.boxes_to_stores[k] = v.shuffle
+        }
+      #end
+      self
+    end
+
+    def run_ga(generations = 10, population_size = 10)
+      @@fitness_values = []
+
+      population = []
+      population_size.times {
+        #ship = OpenShip::Shipment.new(:logger => @logger, :carton_dispenser => @carton_dispenser)
+        ship = self.clone
+        ship.boxes_to_stores = self.boxes_to_stores.clone
+
+        ship.boxes_to_stores.each { |k, v|
+          ship.boxes_to_stores[k] = v.shuffle
+        }
+        population << ship
+      }
+      ga = GeneticAlgorithm.new(population, {:logger => @logger})
+      generations.times { ga.evolve }
+      best_fit = ga.best_fit[0]
+      best_fit.cartons_to_stores.each { |k, v|
+        puts k
+        v.each { |cart|
+          @logger.debug "Carton"
+          cart.box_positions.each { |bp|
+            @logger.debug "length: " + bp.box.length.to_s + " width: " + bp.box.width.to_s + " height: " + bp.box.height.to_s
+            @logger.debug "x: " + bp.position.x.to_s + " y: " + bp.position.y.to_s + " z: " + bp.position.z.to_s
+          }
+        }
+      }
+      best_fit.fitness
+      best_fit
+    end
+
+  end
+
+end

data/lib/open-ship.rb

@@ -0,0 +1,13 @@
+$LOAD_PATH << File.dirname(__FILE__) unless $LOAD_PATH.include?(File.dirname(__FILE__))
+
+module OpenShip
+  
+end
+
+require 'open-ship/sscc'
+require 'open-ship/sortr'
+require 'open-ship/label'
+require 'open-ship/label/carton_label'
+require 'open-ship/label/text_label'
+require 'open-ship/gga4r'
+