eight_corner 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 1e88b701005804c07000bdc9400d2ef5a3fb600a
+  data.tar.gz: 2d7c32b8ff1ac088239d7a77e88dce0fb43cb0be
+SHA512:
+  metadata.gz: f2c979c1e10911131df2324b1bff85d8ce07c682dddb4dde0e0d9bf91015f57ce45f9c9953e8a0e7f0bf7daced26480af9e4e90a2364612bcd581de7b62a5e68
+  data.tar.gz: 140809eb7a083d01906e36f6d9d64033ce53a8181cde9dd16768b63aeefd26ccdf79f19815c55276f44ccaa33f98d5c06a1a462963cdff91f0b36a379ecad6f2

data/.gitignore

@@ -0,0 +1,14 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--require spec_helper

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in eight_corner.gemspec
+gemspec

data/Guardfile

@@ -0,0 +1,18 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+$CELLULOID_DEBUG = false
+
+# Note: The cmd option is now required due to the increasing number of ways
+#       rspec may be run, below are examples of the most common uses.
+#  * bundler: 'bundle exec rspec'
+#  * bundler binstubs: 'bin/rspec'
+#  * spring: 'bin/rsspec' (This will use spring if running and you have
+#                          installed the spring binstubs per the docs)
+#  * zeus: 'zeus rspec' (requires the server to be started separetly)
+#  * 'just' rspec: 'rspec'
+guard :rspec, cmd: 'bundle exec rspec' do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$})     { |m| "spec/lib/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb')  { "spec" }
+end

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Alex Dean
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,57 @@
+# Eight Corner
+
+Draw graphs inspired by [Georg Nees'](https://en.wikipedia.org/wiki/Georg_Nees) [8-corner graphics](http://betonbabe.tumblr.com/post/43724936282/georg-nees-8-corner-generative-computer).
+
+## Example
+
+This code was used to create a poster representing the staff of TED Conferences
+in 2014. There is a [blog post](https://www.deanspot.org/alex/2014/08/21/ted-eightcorner.html)
+about this.
+
+![TED Staff Poster](https://www.deanspot.org/assets/eightcorner/ted_staff_poster.png)
+
+## Algorithm
+
+  1. input is a string
+  1. convert string into 8 2-element arrays. each element is a float
+     in the range 0..1.
+  1. compute a starting point from the string
+  1. for each point element, plot the next point using the 2 floats
+    1. 1st is a direction from the current point
+    1. 2nd is a distance from the current point
+  1. multiple figures in a single body of text may influence each other,
+     meaning that ordering is significant.
+
+## Components
+
+  1. Map a string into 8 elements and a starting point.
+  1. Compute (x,y) points from 8 elements and a starting point.
+  1. Plot points to generate final graphic.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'eight_corner'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install eight_corner
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it ( https://github.com/alexdean/eight_corner/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+

data/eight_corner.gemspec

@@ -0,0 +1,29 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'eight_corner/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "eight_corner"
+  spec.version       = EightCorner::VERSION
+  spec.authors       = ["Alex Dean"]
+  spec.email         = ["alex@crackpot.org"]
+  spec.summary       = %q{Library for generating abstract figures from text strings.}
+  spec.description   = %q{Map text to graphic figures inspired by Georg Nees 'eight corner' project.}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency 'interpolate'
+
+  spec.add_development_dependency "bundler", "~> 1.6"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0.0"
+  spec.add_development_dependency "guard", "~> 2.6.1"
+  spec.add_development_dependency "guard-rspec", "~> 4.3.1"
+  spec.add_development_dependency "ruby_gntp", "~> 0.3.4"
+end

data/lib/eight_corner.rb

@@ -0,0 +1,16 @@
+require 'logger'
+
+require 'interpolate'
+
+require "eight_corner/version"
+require 'eight_corner/base'
+require 'eight_corner/bounds'
+require 'eight_corner/figure'
+require 'eight_corner/quadrant'
+require 'eight_corner/point'
+
+require 'eight_corner/string_mapper'
+require 'eight_corner/svg_printer'
+
+module EightCorner
+end

data/lib/eight_corner/base.rb

@@ -0,0 +1,277 @@
+module EightCorner
+
+  # This class is a catch-all. Will be cleaned up, you know, sometime.
+  class Base
+    def self.validate_options!(options, defaults)
+      unknown_options = options.keys - defaults.keys
+      if unknown_options.size > 0
+        raise ArgumentError, "Unrecognized options: #{unknown_options.inspect}"
+      end
+    end
+
+    def initialize(x_extent, y_extent, options={})
+      defaults = {
+        logger: Logger.new('/dev/null')
+      }
+      self.class.validate_options!(options, defaults)
+
+      options = defaults.merge(options)
+
+      @bounds = Bounds.new(x_extent, y_extent)
+      @point_count = 8
+
+      @log = options[:logger]
+      # @figure_interdepencence = options[:figure_interdepencence]
+    end
+
+    def plot(str, options={})
+      defaults = {
+        group_method: :group2,
+        angle_method: :percentize_modulus_exp,
+        distance_method: :percentize_modulus,
+        start_method: :starting_point,
+        # will the initial_potential, and potentials generated from previous
+        # points in the same figure, be used to alter the angle to the next
+        # point?
+        point_interdependence: true,
+        # 0.5 is 'no change' see angle_potential_interp
+        initial_potential: 0.5
+      }
+      self.class.validate_options!(options, defaults)
+      options = defaults.merge(options)
+
+      mapper = StringMapper.new(group_count: @point_count-1)
+
+      # 7 2-element arrays. each value is a float 0..1.
+      # 1st: % applied to calculate an angle
+      # 2nd: % applied to calculate a distance
+      potentials = mapper.potentials(
+        mapper.groups(str, options[:group_method]),
+        options[:angle_method],
+        options[:distance_method]
+      )
+
+      # the figure we are drawing.
+      figure = Figure.new
+      # set starting point.
+      figure.points << send(options[:start_method], str)
+
+      # a potential is a value derived from the previous point in a figure
+      # these are used to modify the angle used to locate the next point in
+      # the figure. in this way, previous figures add influence
+      # which wouldn't be present if the figure were drawn on its own.
+      #   - median potential (0.5) changes nothing.
+      #   - extremely low potential (0.0) moves the angle 15% counter-clockwise
+      #   - extremely high potential (1.0) moves the angle 15% clockwise
+      angle_potential_interp = Interpolate::Points.new(0.0 => -0.15, 0.5 => 0.0, 1.0 => 0.15)
+
+      # increase low distance potentials to encourage longer lines
+      # this is added to the raw distance potential determined by the string mapper.
+      #   - a distance_pct of 0 will have 0.3 added to it.
+      #   - a distance_pct of 0.5 or greater will have nothing added to it.
+      additional_distance_interp = Interpolate::Points.new(0.0 => 0.3, 0.5 => 0.0)
+
+      previous_potential = options[:initial_potential]
+
+      (@point_count - 1).times do |i|
+        current_point = figure.points[i]
+
+        # TODO encourage more open angles?
+        angle_pct = potentials[i][0]
+        distance_pct = potentials[i][1]
+
+        @log.debug(['angle_pct', angle_pct])
+
+        # if points can influence each other, apply potential from previous
+        # point to the angle-selection process.
+        if options[:point_interdependence]
+          angle_pct_adjustment = angle_potential_interp.at(previous_potential)
+          @log.debug(['angle_pct_adjustment', angle_pct_adjustment])
+
+          @log.debug(['pre-ajustment', angle_pct, angle(current_point, angle_pct)])
+          angle_pct += angle_pct_adjustment
+          @log.debug(['post-ajustment', angle_pct, angle(current_point, angle_pct)])
+        end
+
+        angle_to_next = angle(current_point, angle_pct)
+        dist_to_boundary = distance_to_boundary(current_point, angle_to_next)
+
+        @log.debug(['angle_to_next', angle_to_next])
+        @log.debug(['distance_to_boundary', dist_to_boundary])
+
+        # if we're too close to the edge, go the opposite direction.
+        # so we don't get trapped in a corner.
+        if dist_to_boundary <= 1
+          @log.debug('dist_to_boundary is close to border. adjust angle.')
+
+          angle_to_next += 180
+          angle_to_next %= 360
+          dist_to_boundary = distance_to_boundary(current_point, angle_to_next)
+
+          @log.debug(['after 180: angle_to_next', angle_to_next])
+          @log.debug(['after 180: distance_to_boundary', dist_to_boundary])
+        end
+
+        # how to encourage more space-filling?
+        # track how many points are in each quadrant.
+        # if current point is in the most-populated one, move to least-populated.
+        # if current point and previous point are too close together...
+        # if current point and last point are in different quadrants...
+
+
+        distance_pct += additional_distance_interp.at(distance_pct)
+
+        # longer lines fill space better
+        distance_pct = 0.3 if distance_pct < 0.3
+        # keep away from bounds.
+        distance_pct = 0.9 if distance_pct > 0.9
+
+        distance = dist_to_boundary * distance_pct
+
+        next_point = next_point(
+          current_point,
+          angle_to_next,
+          distance
+        )
+        next_point.angle_pct = angle_pct
+        next_point.distance_pct = distance_pct
+        next_point.created_by_potential = previous_potential
+
+        # TODO: how do we create invalid points?
+        # some bug in distance_to_boundary, most likely.
+        if ! next_point.valid?
+          if next_point.x < 0
+            next_point.x = 0
+          end
+          if next_point.y < 0
+            next_point.y = 0
+          end
+
+          @log.error "point produced invalid next. '#{str}' #{i}"
+          @log.error(['angle_to_next', angle_to_next])
+          @log.error(['distance_to_boundary', dist_to_boundary])
+          @log.error(['next_point', next_point])
+        end
+
+        figure.points << next_point
+        previous_potential = figure.points.last.potential
+      end
+
+      figure
+    end
+
+    # return a starting point for string
+    def starting_point(str)
+      mapper = StringMapper.new
+      raw_x_pct = mapper.percentize_modulus(str)
+      raw_y_pct = mapper.percentize_modulus_exp(str)
+
+      # mapper produces raw %'s 0..1.
+      # figures that start out very close to a border often get trapped and
+      # look strange, so we won't allow a starting point <30% or >70%.
+      interp = Interpolate::Points.new(0 => 0.2, 1 => 0.8)
+
+      x_pct = interp.at( raw_x_pct )
+      y_pct = interp.at( raw_y_pct )
+
+      Point.new(
+        (x_pct * @bounds.x).to_i,
+        (y_pct * @bounds.y).to_i
+      )
+    end
+
+    # pick an angle for the next point
+    # steer away from the corners by avoiding angles which tend toward the
+    # corner we are currently closest to.
+    #
+    # current Point
+    # x & y extents
+    # percent : how far along the arc should we go?
+    #  as a float 0..1
+    #  always counter-clockwise.
+    #
+    # return: an angle from current point.
+    def angle(current, percent)
+
+      range = Quadrant.angle_range_for(@bounds.quadrant(current))
+      interp = Interpolate::Points.new({
+        0 => range.begin,
+        1 => range.end
+      })
+
+      interp.at(percent).to_i % 360
+    end
+
+    # what is the distance from point to extent, along a line of degrees angle
+    def distance_to_boundary(point, degrees)
+      degrees %= 360
+
+      case degrees
+        when 0 then
+          point.x
+
+        when 1..89 then
+          to_top = aas(90-degrees, 90, point.y)
+          to_right = aas(degrees, 90, @bounds.x - point.x)
+          [to_top, to_right].min
+
+        when 90 then
+          @bounds.x - point.x
+
+        when 91..179 then
+          to_right = aas(180-degrees, 90, @bounds.x - point.x)
+          to_bottom = aas(90-180-degrees, 90, @bounds.y - point.y)
+          [to_right, to_bottom].min
+
+        when 180 then
+          @bounds.y - point.y
+
+        when 181..269 then
+          to_bottom = aas(90-degrees-180, 90, @bounds.y - point.y)
+          to_left = aas(degrees - 180, 90, point.x)
+          [to_bottom, to_left].min
+
+        when 270 then
+          point.x
+
+        when 271..359 then
+          to_left = aas(360-degrees, 90, point.x)
+          to_top = aas(90-360-degrees, 90, point.y)
+          [to_left, to_top].min
+
+      end
+    end
+
+    def next_point(last_point, angle, distance)
+      # geometry black magic here. still not positive exactly why this works.
+      # unit circle begins at 90 and goes counterclockwise.
+      # we want to start at 0 and go clockwise
+      # orientation of 0 degrees to coordinate space probably matters also.
+      theta = (180 - angle) % 360
+
+      point = Point.new
+      point.x = (Math.sin(deg2rad(theta)) * distance + last_point.x).round
+      point.y = (Math.cos(deg2rad(theta)) * distance + last_point.y).round
+      point.distance_from_last = distance
+      point.angle_from_last = angle
+      point.bounds = @bounds
+      point
+    end
+
+    def deg2rad(degrees)
+      degrees * Math::PI / 180
+    end
+
+    def rad2deg(radians)
+      radians * 180 / Math::PI
+    end
+
+    # angle, angle, side
+    # A / sin(a) == B / sin(b)
+    # return length of side_B
+    def aas(angle_a, angle_b, side_A)
+      side_A / Math.sin(deg2rad(angle_a)) * Math.sin(deg2rad(angle_b))
+    end
+
+  end
+end