tiledenticon 0.0.1 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c856d1f52ab0369d34a8abd4a42a85d7272b7053
-  data.tar.gz: f3e5d7a662f909d76bc0d1e11db31dfddba547f9
+  metadata.gz: 91badaf0443b9bb80e880a8a54881c93c2335fd2
+  data.tar.gz: 3af121955ad819c7a80d7d95e78ba921bcde29b0
 SHA512:
-  metadata.gz: 65a6ee4426399a52b244a059d70a58e6cbf01dea68b4721cbbb77475d74b6f92d4de68c302bb96f585c00ed027bb1d0cb4bfed1ec96cdd016bfbfb11a140ec10
-  data.tar.gz: 14b4b0cdaf46d353d8055eecfb9e111c5b6553ff4eefe6b1b836c388b24a468a6b215815f46cd6f9f33d8c48d0ff540fc37c199baf13acfae9297036c3bb584b
+  metadata.gz: 3db670823e703c28d7a8a66d90c64bea4c447bc62eea83f7aa0a32138481f67a3b237622ec077ab4db7453db0fe0b9273a53d81831c5332d8d0f453cced8ac79
+  data.tar.gz: f16c265b4dbab6475b9461aa53e6859cdd285fbe2ca53fecf859af2042177c8ef0fbef9934e5f9e2f23107f1868e7d22b7049b43af1115129b3c213e73bffd48

data/lib/face.rb

@@ -1,10 +1,24 @@
+# Warning, documentation written in mathsspeak
+#
 class Face
-  def initialize x, axis1, axis2
-    @pos = x
+  # Represents a 2-dimensional tile with sides of unit length in 4-dimensional
+  # space
+  # V is a vector4 representing the position of the faces base vertex
+  # Axis1 and axis2 are the two canonical axis that the face is aligned with
+  
+  def initialize v, axis1, axis2
+    @pos = v
     @a_min = min(axis1, axis2)
     @a_max = max(axis1, axis2)
   end
 
+  # One iteration of the system
+  # Position is multiplied by translation_matrix
+  # Faces are updated based on algorithm encoded here with switch statements
+  #
+  # There are some cases where the face splits in two, so we return either a new
+  # face or nil
+  
   def tick translation_matrix
     ret = nil
     @pos = translation_matrix * @pos
@@ -45,11 +59,15 @@ class Face
     return ret
   end
 
+  # There are several cases in tick where we 'shunt' the position of the face by
+  # a constant translation
   private def shunt_pos
     a = @pos.to_a
-    @pos = Vector[a[0] - $dirmultx, a[1], a[2], a[3] + $dirmultx]
+    @pos = Vector[a[0] - 1, a[1], a[2], a[3] + 1]
   end
 
+  # Getters
+
   def pos
     @pos
   end
@@ -62,3 +80,13 @@ class Face
     @a_max
   end
 end
+
+# Return min of a series of values
+def min(*values)
+ values.min
+end
+
+# Return max of a series of values
+def max(*values)
+ values.max
+end

data/lib/tiledenticon.rb

@@ -1,32 +1,40 @@
 require 'tiler.rb'
 
 class Tiledenticon
+  # Wrapper for the classes defined in this library
+  
   def initialize out_folder
     @out_folder = out_folder
   end
-  def create input
+
+  def create str
+    # Create a new md5 hasher and feed in the input string
     md5 = Digest::MD5.new
-    md5 << input
+    md5 << str
     hash = md5.hexdigest
+    hr = Hashrander.new hash
 
-    fromMD5 "#{@out_folder}/#{input}.png", hash
+    fromHashrander "#{@out_folder}/#{str}.png", hr
   end
 
+  # Create a series of parameters from an Hashrander
   private
-  def fromMD5 filename, hash
-      r = Hashrander.new(hash)
-      hue = r.get_rand 3, 360
-      s1 = 0.5 + (r.get_rand 2, 0.5)
-      s2 = 0.5 + (r.get_rand 2, 0.5 * s1)
+  def fromHashrander filename, hr
+      hue = hr.get_rand 3, 360
+      s1 = 0.5 + (hr.get_rand 2, 0.5)
+      s2 = 0.4 + (hr.get_rand 2, 0.6 * s1)
 
-      p_x = 0.5 + (r.get_rand 2, 1.15)
-      p_y = 0.5 + (r.get_rand 2, 1.15)
+      p_x = 0.5 + (hr.get_rand 2, 1.15)
+      p_y = 0.5 + (hr.get_rand 2, 1.15)
 
-      TilerBuilder.new(filename).set_hue(hue).set_sat_major(s1).set_sat_minor(s2).set_projection_lambda(p_x, p_y).build
+      TilerBuilder.new(filename).set_hue(hue).set_sat_major(s1).set_sat_minor(s2).set_projection_lambda(p_x, p_y).set_ticks(16).build
   end
 end
 
 class Hashrander
+
+  # Generate random numbers of arbitrary size from a hash
+  
   def initialize hash
     @hash_i = 0
     @hash = hash

data/lib/tiler.rb

@@ -1,30 +1,22 @@
-# From here
-# http://www.mathematicians.org.uk/eoh/files/Harriss_ANGASRP.pdf
-
 require 'face'
 
 require 'chunky_png'
 require 'matrix'
 require 'digest'
 
-def min(*values)
- values.min
-end
-
-def max(*values)
- values.max
-end
+# Warning, documentation written in mathsspeak
 
+# Convert min axis, max axis tuple to an orientation index
+# where axis is between 1 and 4
+# and min_axis < max_axis
 def min_max_to_i min, max
   return max - 1 if min == 0
   return 1 + max if min == 1
   return 5
 end
-$dirmultx = 1
-$dirmulty = 1
-
 
 class TilerBuilder
+  # Builder class for Tiler
 
   def initialize filename
     @hue = 345
@@ -87,32 +79,44 @@ end
 
 class Tiler
 
+  # The matrix that we multiply against the position of every face on tick
   @@translation_matrix = 
     Matrix[[0, 0, 0, -1],
-           [1, 0, 0, 0],
-           [0, 1, 0, 0],
-           [0, 0, 1, 1]]
+           [1, 0, 0,  0],
+           [0, 1, 0,  0],
+           [0, 0, 1,  1]]
 
   def initialize image_width, image_height, scale, hue, sat_major, sat_minor, projection_lambda
+    
+    # We colour based on face orientation index, 
+    # 0 and 1 being white
+    # 2 and 4 based on hue
+    # 3 and 5 based on the compliment of hue
+
     @h1 = hue
     @h2 = (hue + 360/2) % 360
-
+    
     @colors = [
       ChunkyPNG::Color.from_hsv(0, 0, 1),
       ChunkyPNG::Color.from_hsv(0, 0.0, 1),
-      ChunkyPNG::Color.from_hsv(@h1, sat_major, 1),
-      ChunkyPNG::Color.from_hsv(@h2, sat_major, 1),
+      ChunkyPNG::Color.from_hsv(@h1, sat_major, 0.9),
+      ChunkyPNG::Color.from_hsv(@h2, sat_major, 0.9),
       ChunkyPNG::Color.from_hsv(@h1, sat_minor, 0.6),
       ChunkyPNG::Color.from_hsv(@h2, sat_minor, 0.6)
     ]
 
-
     @image_width = image_width
     @image_height = image_height
+
+    # (ox,oy) describes the centre of the image
     @ox = @image_width/2
     @oy = @image_height/2
+
+    # Scale is the length in pixels of the unit distance when rendered
     @scale = scale
 
+    # Construct the projection of 4 dimensional space onto the output image
+    # (cononical_x[i],cononical_y[i]) describes the projection of e_i
     @canonical_x = []
     @canonical_y = []
     for i in 0..3 do
@@ -120,19 +124,23 @@ class Tiler
       @canonical_x << c.real
       @canonical_y << c.imaginary
     end
-    @all_faces = [Face.new(Vector[0, 0, 0, 0], 2, 3)]
-  end
 
+    # Add an initial face to the list of faces
+    @all_faces = [Face.new(Vector[0, 0, 0, 0], 2, 3)]
 
+  end
 
-  def to_image_space p
-    {x: (@ox + @global_xo -@scale * (p[0] * @canonical_x[0] + p[1] * @canonical_x[1] + 
+  # Convert a positional vector 4 to image space
+  def to_image_space p, origin_x, origin_y
+    {x: (origin_x - @scale * (p[0] * @canonical_x[0] + p[1] * @canonical_x[1] + 
                  p[2] * @canonical_x[2] + p[3] * @canonical_x[3])),
-     y: (@oy + @global_yo + @scale * (p[0] * @canonical_y[0] + p[1] * @canonical_y[1] + 
+     y: (origin_y + @scale * (p[0] * @canonical_y[0] + p[1] * @canonical_y[1] + 
                  p[2] * @canonical_y[2] + p[3] * @canonical_y[3]))};
   end
 
   def tile ticks, filename
+
+    # Iterate all faces ticks times
     for i in 1 .. ticks
       new_list = []
       @all_faces.each do |face|
@@ -141,42 +149,59 @@ class Tiler
         new_list << ret unless ret.nil?
       end
       @all_faces = new_list
+    end
 
-      @global_xo = 0
-      @global_yo = 0
-      p = to_image_space(@all_faces[0].pos.to_a)
-      @global_xo = @ox - p[:x]
-      @global_yo = @oy - p[:y]
-
+    # (global_xo, global_yo) is a translation of the entire rendered surface
+    # we do this to centre on a region that is actually tiled
+    
+    @global_xo = 0
+    @global_yo = 0
+
+    # For now we focus on the average position of all faces
+    @all_faces.each do |face|
+      p = to_image_space(face.pos.to_a, @ox, @oy)
+      @global_xo += (@ox - p[:x])/@all_faces.length
+      @global_yo += (@oy - p[:y])/@all_faces.length
     end
 
     # Draw
-    image = ChunkyPNG::Image.new(@image_width, @image_height, ChunkyPNG::Color::TRANSPARENT)
-
     puts "Tiledenticon: Drawing image"
+    
+    # Create a new, blank image
+    image = ChunkyPNG::Image.new @image_width, @image_height, @colors[5]
+
+    draw_x = @global_xo + @ox
+    draw_y = @global_yo + @oy
+
     @all_faces.each_with_index do |face, i|
       print "Tiledenticon: Face #{i}\r"
 
-      p1 = to_image_space (face.pos.to_a)
+      # Generate the points to a from each face for rendering
+
+      p1 = to_image_space  face.pos.to_a, draw_x, draw_y
 
       p2_m = face.pos.to_a
       p2_m[face.min_axis] += 1
-      p2 = to_image_space(p2_m) 
+      p2 = to_image_space p2_m, draw_x, draw_y
 
       p3_m = face.pos.to_a
       p3_m[face.max_axis] += 1
-      p3 = to_image_space(p3_m) 
+      p3 = to_image_space p3_m, draw_x, draw_y
 
       p4_m = face.pos.to_a
       p4_m[face.min_axis] += 1
       p4_m[face.max_axis] += 1
-      p4 = to_image_space(p4_m) 
-
+      p4 = to_image_space p4_m, draw_x, draw_y
 
       points = ChunkyPNG::Vector.new([p1, p2, p4, p3])
+
+      # Pick colour based on colour scheme in @colors array and the direcion the
+      # face is orientated
       color = @colors[min_max_to_i face.min_axis, face.max_axis]
+
       image.polygon(points, ChunkyPNG::Color::TRANSPARENT, color) 
     end
+
     puts "\nTiledenticon: Saving image to #{filename}"
     image.save(filename, :interlace => false)
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: tiledenticon
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.1.0
 platform: ruby
 authors:
 - Dan Slocombe