wicket 0.0.2 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a1d5db24047874cba578ee40d7b03c7ec2e204f5
-  data.tar.gz: 70c327e69d7a54897fa73436eb13b5d175a5711c
+  metadata.gz: bd072dfef6d4eb66f52974a60e5b6a1df82c24a3
+  data.tar.gz: a3e29991b47184b46eff7801a3678a7dc7c4d2fd
 SHA512:
-  metadata.gz: 00f66f02b83314f43d2567e7c2324223dd0d769036c27bf9571896330ea485703724a0c3a5d155ed66cab9757c8c7f567cc1f490dcfb474cd9af0739769e8243
-  data.tar.gz: 65885c4b9f665eee96d41cf70ecf1e6587befb6fe64612849df94a281d12198804d6f966a669569a545b45871dbc632a625adefe900fe03057a9f6fdbcd4a047
+  metadata.gz: d22c55c1e9ade2cc8d48e7d5c2a579e5e88f980b81dc7ae67a3ee89a58260eefa49b5828a163dd09a89906162dfaf33907b5307ffdc0593aadb0c98523a24792
+  data.tar.gz: b38949f08bd4eaaa4966cb54f8dbe36ab48693edef333373d558a36418e77e22bd5b9051edb6778960384782e4b4e183e801f908d655b52205b24e119007e9f0

data/.travis.yml

@@ -1,11 +1,8 @@
 language: ruby
 rvm:
-  - 2.1.0
+  - 2.1
   - 2.0.0
   - 1.9.3
-  - 1.8.7
-  - jruby-18mode
   - jruby-19mode
-  - rbx
   - ruby-head
-script: rspec
+script: rspec

data/Gemfile

@@ -2,3 +2,5 @@ source 'https://rubygems.org'
 
 # Specify your gem's dependencies in wicket.gemspec
 gemspec
+
+gem "pry"

data/README.md

@@ -8,17 +8,20 @@ Notable features include:
 - Translating line paths into WKT Polygons or Multipolygons
 - Accepting absolute or relative path commands
 - Inversing Y axis measurements (SVG y coordinates decrease as you go up)
+- Translates quadratic and cubic curve commands into straight line segments
+- Curve definition translation controls
+- Numeric precision controls
 - Decimal math for increased accuracy
 
 Future possible features could include:
-- Translating curved paths
+- The arc "A" command
 - Translating non closed paths into Linestrings and Multilines
 - Specifying paths for polygons which are exlcusions from the area (donut holes)
 - Translating WKT to SVG (although PostGIS already does this)
 
 If you want to see these or any other features, feel free to make an issue or pull request.
 
-Wicket is similar in concept to [SVG-to-WKT.js](https://github.com/davidmcclure/svg-to-wkt), although that project operates within the browser and focuses much more on the DOM elements. It also owes credit to [Savage](https://github.com/awebneck/savage) as a reference for the SVG parser. If you need to edit SVG paths, I would recommend checking it out.
+Wicket is similar in concept to [SVG-to-WKT.js](https://github.com/davidmcclure/svg-to-wkt), although that project operates within the browser. It also owes credit to [Savage](https://github.com/awebneck/savage) as a reference for the SVG parser. If you need to edit SVG paths, I would recommend checking it out.
 
 ## Installation
 
@@ -34,35 +37,152 @@ Or install it yourself as:
 
     $ gem install wicket
 
+## Configuration
+
+You can pass configuration parameters to Wicket at three times:
+
+- At load time, using an initializer
+
+```ruby
+Wicket.configure do |w|
+  w.min_angle = 165
+  w.min_angle_unit = :degrees
+end
+```
+
+- At instantiation time (overrides the initializer)
+
+```ruby
+Wicket::SVGPath.new("M10 10H20l10 10H10z",
+  min_angle: 165,
+  min_angle_unit: :degrees
+)
+```
+
+- At conversion time (overrides the initializer and instantiation)
+
+```ruby
+  path = Wicket::SVGPath.new("M10 10H20l10 10H10z")
+  path.to_polygon(min_angle: 165, min_angle_unit: :degrees)
+```
+
+### Configuration Options
+
+There are currently two configuration options:
+
+1. `min_angle`
+
+  This is the minimum angle allowed when translating a curve into a series of straight lines. A higher minimum will require more line segments, more vertices, and more text, but it will get you a more accurate line.
+
+  There are 4 ways to describe an angle to Wicket, and luckily Wicket is pretty smart about figuring out which one you want, although, as noted below, you can explicitly state which one you want.
+
+  1. `decimal_percentage`
+
+    If the `min_angle` is greater than 0 and less than 1, Wicket assumes you are expressing a decimal percentage of the maximum total angle (180 degrees, or Pi radians). For example, 0.9 would indicate that you only want to allow angles of 0.9 * Pi radians or 0.9 * 180 degrees.
+
+  2. `radians`
+
+    If the `min_angle` is greater than or equal to 1 and less than Pi, it will assume you are talking in radians.
+
+  3. `percentage`
+
+    If the `min_angle` is greater than or equal to Pi, and less than 100 it will assume you are talking in percentage terms. This is the same as #1 except multiplied by 100.
+
+  4. `degrees`
+
+    If the `min_angle` is greater than or equal to 100, but less than 180, it will assume you are talking in degrees.
+
+  Obviously, this must be a numeric value greater than 0 and less than 180.
+
+2. `min_angle_unit`
+  
+  As noted above, this should rarely be necessary, but sometimes it can be included for explcitness in the code, or in rare cases, used to override Wicket's guess as to what unit you are using. For example, if you for some reason wanted the `min_angle` to be 0.5 radians, you could explicitly state so and Wicket would comply. This would, however, result in a pretty poorly fit curve, since the above guesses cover all obtuse angles in all four formats.
+
+  This option accepts the same four arguments as above: `decimal_percentage`,`radians`, `percentage`, and `degrees`
+
+3. `scale`
+  
+  This is the number of digits allowed after the decimal point, exactly as you would in a Rails migration for a decimal column. Note that this is only used for formatting, all calculations are done to the maximum possible precision.
+
+  If scale is omitted, Wicket will use the greatest scale of all the input points provided. Thus:
+  
+  ```
+  "M0,0H100V100H0z" # => 0 scale
+  "M0,0H100V100H0.0z" # => 1 scale
+  "M0,0H100V100H0.00z" # => 2 scale
+  "M0.000,0H100V100H0.00z" # => 3 scale
+  ```
+
 ## Usage
 
+### Linear paths
 ```ruby
 # one subpath
 path = Wicket::SVGPath.new("M10 10H20l10 10H10z")
 path.to_polygon 
-  # => "POLYGON((10.0 -10.0,20.0 -10.0,30.0 -20.0,10.0 -20.0,10.0 -10.0))"
+  # => "POLYGON((10 -10,20 -10,30 -20,10 -20,10 -10))"
 path.to_multipolygon 
-  # => "MULTIPOLYGON(((10.0 -10.0,30.0 -10.0,40.0 -10.0,50.0 -20.0,40.0 -20.0,10.0 -10.0)))"
+  # => "MULTIPOLYGON(((10 -10,20 -10,30 -20,10 -20,10 -10)))"
 
 # two subpaths
 path = Wicket::SVGPath.new("M10 10H20l10 10H10z M100 100h10v10h-10z")
 path.to_polygon # ONLY THE FIRST SUBPATH!
-  # => "POLYGON((10.0 -10.0,20.0 -10.0,30.0 -20.0,10.0 -20.0,10.0 -10.0))"
+  # => "POLYGON((10 -10,20 -10,30 -20,10 -20,10 -10))"
+path.to_multipolygon # both subpaths
+  # => "MULTIPOLYGON(((10 -10,30 -10,40 -10,50 -20,40 -20,10 -10)),((100 -100,110 -100,110 -110,100 -110,100 -100)))
+
+```
+
+### Curved paths
+```ruby
+# cubic
+path = Wicket::SVGPath.new("M100 100,c0 200,200 200,200 0z")
+path.to_polygon 
+  # => "POLYGON((100 -100,102 -135,108 -165,131 -212,146 -228,163 -240,181 -247,200 -250,218 -247,236 -240,253 -228,268 -212,281 -191,291 -165,300 -100,100 -100))"
+path.to_multipolygon 
+  # => "MULTIPOLYGON(((100 -100,102 -135,108 -165,131 -212,146 -228,163 -240,181 -247,200 -250,218 -247,236 -240,253 -228,268 -212,281 -191,291 -165,300 -100,100 -100)))"
+
+# quadratic
+path = Wicket::SVGPath.new("M10 10,Q110 210 210 10z")
+path.to_polygon
+  # => "POLYGON((10 -10,35 -53,60 -85,72 -95,85 -103,97 -108,110 -110,122 -108,135 -103,147 -95,160 -85,185 -53,210 -10,10 -10))"
 path.to_multipolygon # both subpaths
-  # => "MULTIPOLYGON(((10.0 -10.0,30.0 -10.0,40.0 -10.0,50.0 -20.0,40.0 -20.0,10.0 -10.0)),((100 -100,110 -100,110 -110,100 -110,100 -100)))
+  # => "MULTIPOLYGON(((10 -10,35 -53,60 -85,72 -95,85 -103,97 -108,110 -110,122 -108,135 -103,147 -95,160 -85,185 -53,210 -10,10 -10)))
+
+```
+
+## Debugging/Proof
+
+Because this is all pretty hard to keep track of in your head, you can call `#to_svg` on any path, and it will output a SVG of your original path in blue and a representation of the WKT in green for visual comparison, ready to paste into a page or JSFiddle or something. You may have to adjust the viewbox to make sure the path is visible. `#to_svg` takes all the same parameters as `#to_polygon`.
+
+```ruby
+path = Wicket::SVGPath.new("M0 0,C0 200,200 200,200 0z")
+puts path.to_svg
+  # <svg>
+  #   <path d="M0 0,C0 200,200 200,200 0z" style="fill: slateblue; opacity:0.2"/>
+  #   <path d="M0,0 L 2,35 8,65 31,112 46,128 63,140 81,147 100,150 118,147 136,140 153,128 168,112 181,91 191,65 200,0 Z" style="fill:none;stroke:lawngreen" stroke-weight="2"/>
+  # </svg>
 
 ```
 
 ## Gotchas
 
-- Wicket assumes that a move command (M or m) is part of the polygon edge. It just so happened that a lot of the data I was working with when creating this project was formatted that way. Eventually I believe this should not be the case and should be able to be toggled on as an option.
+- Be careful when using curves that you have an appropriate scale set for the magnitude of the numbers you are using. If you are dealing with small numbers, curves, and your inputs are integers, all the points will be rounded to integers. You probably don't want that.
+
+  ```ruby
+  path = Wicket::SVGPath.new("M0,0Q1,1,2,0z")
+  path.to_polygon # probably not what you want
+    # => "POLYGON((0 0,0 0,0 0,0 0,1 0,1 0,1 0,1 0,2 0,0 0))"
+  path.to_polygon(scale: 4) # much better
+    # => "POLYGON((0.0 -0.0,0.25 -0.2188,0.5 -0.375,0.75 -0.4688,1.0 -0.5,1.25 -0.4688,1.5 -0.375,1.75 -0.2188,2.0 -0.0,0.0 -0.0))"
+  ```
+- Wicket assumes that a move command (M or m) is part of the polygon edge. It just so happened that a lot of the data I was working with when creating this project was formatted that way. If your cursor moves around a lot and does not intend to define these as edges, be aware.
 - Polygons are assumed to have no holes, thus everything inside the path is part of the polygon.
 - Each polygon is represented by a subpath. A subpath continues until it is closed by a Z command. Multiple subpaths are represented as individual elements in `#to_multipolygon`, whereas only the first subpath is represented in `#to_polygon`. Make sure your data does not include multiple subpaths if using the `#to_polygon` method.
+- "-0.0" is a possible value, [as negative zero is a concept in BigDecimal](http://www.ruby-doc.org/stdlib-1.9.3/libdoc/bigdecimal/rdoc/BigDecimal.html#class-BigDecimal-label-Positive+and+negative+zero).
 
 ## Contributing
 
-1. Fork it ( http://github.com/rurabe/wicket/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 new Pull Request
+If you have a path that you think is being mistranslated, please submit a pull request with your path added to `spec/test_cases.yml`, and if possible, the fix.
+
+Otherwise, submit a pull request for any other feature.

data/changelog.md

@@ -0,0 +1,12 @@
+# Changelog
+
+## 0.0.3
+<!-- - Converts C commands -->
+
+## 0.0.2
+- Converts Z, L, H, and V commands
+- Added README
+
+## 0.0.1
+- Initial release
+- Converts M commands

data/lib/wicket.rb

@@ -1,13 +1,35 @@
 require "bigdecimal"
+require 'bigdecimal/util'
 require "wicket/version"
+require "wicket/utilities"
+require "wicket/cartesian"
+require "wicket/configuration"
+require "wicket/coordinate"
+require "wicket/subpoint"
 require "wicket/svg_path"
 require "wicket/subpath"
+require "wicket/commands/bezier_curve"
+require "wicket/commands/cubic_bezier"
+require "wicket/commands/quadratic_bezier"
 require "wicket/command"
 require "wicket/commands/m"
 require "wicket/commands/l"
 require "wicket/commands/z"
 require "wicket/commands/h"
 require "wicket/commands/v"
+require "wicket/commands/c"
+require "wicket/commands/s"
+require "wicket/commands/q"
+require "wicket/commands/t"
+
 
 module Wicket
+  class << self
+    attr_reader :configuration
+    def configure
+      @configuration ||= Configuration.new
+      yield(@configuration)
+    end
+  end
+  configure {}
 end

data/lib/wicket/cartesian.rb

@@ -0,0 +1,23 @@
+module Wicket
+  module Cartesian
+
+    def distance_to(remote)
+      Math.sqrt((remote.x - x) ** 2 + (remote.y - y) ** 2)
+    end
+
+    def to_wkt(o={})
+      [format(x,o),format((y * -1),o)].join(" ")
+    end
+
+    def to_svg(o={})
+      [x,y].map{|a| format(a,o)}.join(",")
+    end 
+
+    private
+
+      def format(n,opts={})
+        Utilities.format(n,opts)
+      end
+
+  end
+end

data/lib/wicket/command.rb

@@ -1,45 +1,78 @@
 module Wicket
   class Command
-    attr_reader :cursor_start
+    attr_reader :cursor_start, :x, :y
 
     class << self
-      def from_code(code,arg_string,subpath)
+      def from_code(code,arg_string,subpath,opts={})
         command_class = Commands.const_get(code.upcase) # get the class which handles this code
         absolute = (code.upcase == code) # is it uppercase?
         cursor_start = subpath.cursor_end # get the current position of the cursor
         args = arg_string.to_s.scan(/(?:\-\s*)?\d+(?:\.\d+)?/).flatten # parse out the numerical arguments
         if !args.empty?
-          generate_commands(args,command_class,absolute,cursor_start)
+          set_scale!(args,opts)
+          generate_commands(args,command_class,absolute,cursor_start,subpath,opts)
         else # Must be a Z command
-          [command_class.new(absolute,cursor_start)]
+          [command_class.new(absolute,cursor_start,subpath,opts)]
         end
       end
 
       private
 
-        def generate_commands(args,command_class,absolute,cursor_start)
-          args.each_slice(command_class.arg_count).map do |slice| # slice them according to the number the code takes
+        def generate_commands(args,command_class,absolute,cursor_start,subpath,opts={})
+          args.each_slice(command_class::ARGS).map do |slice| # slice them according to the number the code takes
             slice.map!{|arg| BigDecimal.new(arg.gsub(/\s*/,'')) } # remove whitespace and turn into a decimal
-            command_class.new(absolute,cursor_start,*slice)
+            command_class.new(absolute,cursor_start,subpath,opts,*slice)
           end
         end
+
+        def set_scale!(args,opts={})
+          opts[:_scale] = [opts[:_scale].to_i,args.map{|s| d = s.split(".")[1]; d ? d.length : 0 }.max].max
+        end
     end
 
     def subpath=(subpath)
       @subpath = subpath
     end
 
-    def inspect
-      "#<#{self.class.to_s} #{coordinates.map{|k,v|[k,v].join("=")}.join(",")}#{" abs" if @absolute}>"
+    def absolute_x
+      @absolute ? x : cursor_start.x + ( @x || 0 )
     end
 
-    def to_wkt
-      inverse_values.join(" ")
+    def absolute_y
+      @absolute ? y : cursor_start.y + ( @y || 0 )
     end
 
-      private
-        def inverse_values
-          [cursor_end[:x].to_s("F"), (cursor_end[:y] * -1).to_s("F")]
+    def cursor_end
+      Coordinate.new(absolute_x,absolute_y)
+    end
+
+    def to_wkt(opts={})
+      o = @opts.merge(opts)
+      cursor_end.to_wkt(o)
+    end
+
+    def to_svg(opts={})
+      o = @opts.merge(opts)
+      [letter,cursor_end.to_svg(o)].join("")
+    end
+
+    def arguments
+      self.class::ARG_LIST.each_with_object({},&arg_maker)
+    end
+
+    private
+
+      def letter
+        self.class.to_s.match(/\:\:([^\:]+)$/)[1]
+      end
+
+      def arg_maker
+        Proc.new do |att,hash|
+          hash.merge!(att => instance_variable_get("@#{att}"))
         end
+      end
+
+
+
   end
 end

data/lib/wicket/commands/bezier_curve.rb

@@ -0,0 +1,75 @@
+module Wicket
+  module Commands
+    module BezierCurve
+
+      def evaluate_curve(t)
+        x = de_casteljau(:x,t,*control_points)
+        y = de_casteljau(:y,t,*control_points)
+        [x,y,t]
+      end
+
+      def to_wkt(opts={})
+        o = @opts.merge(opts)
+        subpoints(o).reject{|s| s.t == 0 }.map{|s| s.to_wkt(o) }.join(",")
+      end
+
+      def to_svg(opts={})
+        o = @opts.merge(opts)
+        "L #{subpoints(o).reject{|s| s.t == 0}.map{|s| s.to_svg(o) }.join(" ")}"
+      end
+
+      private
+
+        def subpoints(opts)
+          points = init_subpoints
+          smooth(points,new_point(points,*points),opts)
+          points.sort_by(&:t)
+        end
+
+        def de_casteljau(axis,t,*points)
+          n = (points.length - 1)
+          points.each_with_index.inject(0) do |m,(p,i)|
+            m + ( choose(n,i) * ((1-t) ** (n-i)) * (t ** i) * p.send(axis))
+          end
+        end
+
+        def choose(n,k)
+          (0...k).inject(1){ |m,i| (m * (n - i)) / (i + 1) }.to_d
+        end
+
+        def smooth(points,point,opts)
+          if point_needed?(point,opts)
+            smooth(points,new_point(points,point,point.previous_neighbor),opts)
+            if point_needed?(point,opts)
+              smooth(points,new_point(points,point,point.next_neighbor),opts)
+            end
+          end
+        end
+
+        # is the angle more than the tolerance?
+        def point_needed?(point,opts)
+          point.angle < Utilities.radians_tolerance(opts)
+        end
+
+        def new_point(points,point,neighbor)
+          x,y,t = evaluate_curve((point.t + neighbor.t) / 2.0)
+          Subpoint.new(x,y,t,points)
+        end
+
+        def init_subpoints
+          [].tap do |a|
+            Subpoint.from_coordinate(@cursor_start,0,a)
+            Subpoint.from_coordinate(cursor_end,1,a)
+          end
+        end
+
+        def set_implicit_control_point!
+          if @absolute
+            @c1x,@c1y = implied_c1.x,implied_c1.y
+          else
+            @c1x,@c1y = @cursor_start.relativize(implied_c1)
+          end
+        end
+    end
+  end
+end