savage-transform 1.3.0

data/lib/savage/directions/point_target.rb

@@ -0,0 +1,22 @@
+module Savage
+  module Directions
+    class PointTarget < Direction
+
+      attr_accessor :target
+
+      def initialize(x, y, absolute=true)
+        @target = Point.new(x,y)
+        super(absolute)
+      end
+
+      def to_a
+        [command_code, @target.x, @target.y]
+      end
+
+      def movement
+        [target.x, target.y]
+      end
+
+    end
+  end
+end

data/lib/savage/directions/quadratic_curve_to.rb

@@ -0,0 +1,44 @@
+module Savage
+  module Directions
+    class QuadraticCurveTo < PointTarget
+      attr_accessor :control
+
+      def initialize(*args)
+        raise ArgumentError if args.length < 2
+        case args.length
+        when 2
+          super(args[0],args[1],true)
+        when 3
+          raise ArgumentError if args[2].kind_of?(Numeric)
+          super(args[0],args[1],args[2])
+        when 4
+          @control = Point.new(args[0],args[1])
+          super(args[2],args[3],true)
+        when 5
+          @control = Point.new(args[0],args[1])
+          super(args[2],args[3],args[4])
+        end
+      end
+
+      def to_a
+        if @control
+          [command_code, @control.x, @control.y, @target.x, @target.y]
+        else
+          [command_code, @target.x, @target.y]
+        end
+      end
+
+      def command_code
+        return (absolute?) ? 'Q' : 'q' if @control
+        (absolute?) ? 'T' : 't'
+      end
+
+      def transform(scale_x, skew_x, skew_y, scale_y, tx, ty)
+        # relative line_to dont't need to be tranlated
+        tx = ty = 0 if relative?
+        transform_dot( target,  scale_x, skew_x, skew_y, scale_y, tx, ty)
+        transform_dot( control, scale_x, skew_x, skew_y, scale_y, tx, ty) if control
+      end
+    end
+  end
+end

data/lib/savage/directions/vertical_to.rb

@@ -0,0 +1,31 @@
+module Savage
+  module Directions
+    class VerticalTo < CoordinateTarget
+      def command_code
+        (absolute?) ? 'V' : 'v'
+      end
+
+      def transform(scale_x, skew_x, skew_y, scale_y, tx, ty)
+
+        unless skew_x.zero?
+          raise 'rotating or skewing (in X axis) an "vertical_to" direction is not supported yet.'
+        end
+        
+        self.target *= scale_y
+        self.target += ty if absolute?
+      end
+
+      def to_fully_transformable_dir( pen_x, pen_y )
+        if absolute?
+          LineTo.new( pen_x, target, true )
+        else
+          LineTo.new( 0, target, false )
+        end
+      end
+
+      def movement
+        [nil, target]
+      end
+    end
+  end
+end

data/lib/savage/parser.rb

@@ -0,0 +1,108 @@
+module Savage
+  class Parser
+    DIRECTIONS = {
+      :m => {:class => Directions::MoveTo,
+             :args => 2},
+      :l => {:class => Directions::LineTo,
+             :args => 2},
+      :h => {:class => Directions::HorizontalTo,
+             :args => 1},
+      :v => {:class => Directions::VerticalTo,
+             :args => 1},
+      :c => {:class => Directions::CubicCurveTo,
+             :args => 6},
+      :s => {:class => Directions::CubicCurveTo,
+             :args => 4},
+      :q => {:class => Directions::QuadraticCurveTo,
+             :args => 4},
+      :t => {:class => Directions::QuadraticCurveTo,
+             :args => 2},
+      :a => {:class => Directions::ArcTo,
+             :args => 7}
+    }
+
+    class << self
+      def parse(parsable)
+        raise TypeError if parsable.class != String
+        subpaths = extract_subpaths parsable
+        raise TypeError if (subpaths.empty?)
+        path = Path.new
+        path.subpaths = []
+        subpaths.each_with_index do |subpath, i|
+          path.subpaths << parse_subpath(subpath, i == 0)
+        end
+        path
+      end
+      
+      private
+        def extract_subpaths(parsable)
+          subpaths = []
+          if move_index = parsable.index(/[Mm]/)
+            subpaths << parsable[0...move_index] if move_index > 0
+            parsable.scan(/[Mm](?:\d|[eE.,+-]|[LlHhVvQqCcTtSsAaZz]|\W)+/m) do |match_group|
+              subpaths << $&
+            end
+          else
+            subpaths << parsable
+          end
+          subpaths
+        end
+        
+        def parse_subpath(parsable, force_absolute=false)
+          subpath = SubPath.new
+          subpath.directions = extract_directions parsable, force_absolute
+          subpath
+        end
+        
+        def extract_directions(parsable, force_absolute=false)
+          directions = []
+          i = 0
+          parsable.scan(/[MmLlHhVvQqCcTtSsAaZz](?:\d|[eE.,+-]|\W)*/m) do |match_group|
+            direction = build_direction $&, force_absolute && i == 0
+            if direction.kind_of?(Array)
+              directions.concat direction
+            else
+              directions << direction
+            end
+            i += 1
+          end
+          directions
+        end
+        
+        def build_direction(parsable, force_absolute=false)
+          directions = []
+          @coordinates = extract_coordinates parsable
+          recurse_code = parsable[0,1]
+          first_absolute = force_absolute
+          
+          # we need to handle this separately, since ClosePath doesn't take any coordinates
+          if @coordinates.empty? && recurse_code =~ /[Zz]/
+            directions << Directions::ClosePath.new(parsable[0,1] == parsable[0,1].upcase)
+          end
+          
+          until @coordinates.empty?
+            absolute = (first_absolute || parsable[0,1] == parsable[0,1].upcase)
+            directions << construct_direction(recurse_code.strip[0].downcase.intern, absolute)
+            recurse_code = 'L' if recurse_code.downcase =~ /m/
+            first_absolute = false
+          end
+          
+          directions
+        end
+
+        def construct_direction(recurse_code, absolute)
+          args = @coordinates.shift DIRECTIONS[recurse_code][:args]
+          raise TypeError if args.any?(&:nil?)
+          DIRECTIONS[recurse_code][:class].new(*args, absolute)
+        end
+        
+        def extract_coordinates(command_string)
+          coordinates = []
+          command_string.scan(/-?\d+(\.\d+)?([eE][+-]?\d+)?/) do |match_group|
+            coordinates << $&.to_f
+          end
+          coordinates
+        end
+    end
+  end
+end

data/lib/savage/path.rb

@@ -0,0 +1,66 @@
+module Savage
+  class Path
+    require File.dirname(__FILE__) + "/direction_proxy"
+    require File.dirname(__FILE__) + "/sub_path"
+
+    include Utils
+    include DirectionProxy
+    include Transformable
+
+    attr_accessor :subpaths
+
+    define_proxies do |sym,const|
+      define_method(sym) do |*args|
+        @subpaths.last.send(sym,*args)
+      end
+    end
+
+    def initialize(*args)
+      @subpaths = [SubPath.new]
+      @subpaths.last.move_to(*args) if (2..3).include?(*args.length)
+      yield self if block_given?
+    end
+
+    def directions
+      directions = []
+      @subpaths.each { |subpath| directions.concat(subpath.directions) }
+      directions
+    end
+
+    def move_to(*args)
+      unless (@subpaths.last.directions.empty?)
+        (@subpaths << SubPath.new(*args)).last
+      else
+        @subpaths.last.move_to(*args)
+      end
+    end
+
+    def closed?
+      @subpaths.last.closed?
+    end
+
+    def to_command
+      @subpaths.collect { |subpath| subpath.to_command }.join
+    end
+
+    def transform(*args)
+      dup.tap do |path|
+        path.to_transformable_commands!
+        path.subpaths.each {|subpath| subpath.transform *args }
+      end
+    end
+
+    # Public: make commands within transformable commands
+    #         H/h/V/v is considered not 'transformable'
+    #         because when they are rotated, they will
+    #         turn into other commands
+    def to_transformable_commands!
+      subpaths.each &:to_transformable_commands!
+    end
+
+    def fully_transformable?
+      subpaths.all? &:fully_transformable?
+    end
+
+  end
+end

data/lib/savage/sub_path.rb

@@ -0,0 +1,78 @@
+module Savage
+  class SubPath
+    include Utils
+    include DirectionProxy
+    include Transformable
+
+    define_proxies do |sym,const|
+      define_method(sym) do |*args|
+        raise TypeError if const == "QuadraticCurveTo" && @directions.last.class != Directions::QuadraticCurveTo && [2,3].include?(args.length)
+        raise TypeError if const == "CubicCurveTo" && @directions.last.class != Directions::CubicCurveTo && [4,5].include?(args.length)
+        (@directions << Savage::Directions.const_get(const).new(*args)).last
+      end
+    end
+
+    attr_accessor :directions
+
+    def move_to(*args)
+      return nil unless @directions.empty?
+      (@directions << Directions::MoveTo.new(*args)).last
+    end
+
+    def initialize(*args)
+      @directions = []
+      move_to(*args) if (2..3).include?(args.length)
+      yield self if block_given?
+    end
+
+    def to_command
+      @directions.to_enum(:each_with_index).collect { |dir, i|
+        command_string = dir.to_command
+        if i > 0
+          prev_command_code = @directions[i-1].command_code
+          if dir.command_code == prev_command_code || (prev_command_code.match(/^[Mm]$/) && dir.command_code == 'L')
+            command_string.gsub!(/^[A-Za-z]/,'')
+            command_string.insert(0,' ') unless command_string.match(/^-/)
+          end
+        end
+        command_string
+      }.join
+    end
+
+    def commands
+      @directions
+    end
+
+    def closed?
+      @directions.last.kind_of? Directions::ClosePath
+    end
+
+    def transform(*args)
+      directions.each { |dir| dir.transform *args }
+    end
+
+    def to_transformable_commands!
+      if !fully_transformable?
+        pen_x, pen_y = 0, 0
+        directions.each_with_index do |dir, index|
+          unless dir.fully_transformable?
+            directions[index] = dir.to_fully_transformable_dir( pen_x, pen_y )
+          end
+
+          dx, dy = dir.movement
+          if dir.absolute?
+            pen_x = dx if dx
+            pen_y = dy if dy
+          else
+            pen_x += dx if dx
+            pen_y += dy if dy
+          end
+        end
+      end
+    end
+
+    def fully_transformable?
+      directions.all? &:fully_transformable?
+    end
+  end
+end

data/lib/savage/transformable.rb

@@ -0,0 +1,59 @@
+require 'bigdecimal'
+require 'bigdecimal/util'
+
+module Savage
+
+  module Transformable
+
+    # Matrix 2D:
+    # | a, c, e |
+    # | b, d, f |
+    # | 0, 0, 1 |
+    def transform(a, b, c, d, e, f)
+    end
+
+    def translate(tx, ty=0)
+      transform( 1, 0, 0, 1, tx, ty )
+    end
+
+    def scale(sx, sy=sx)
+      transform( sx, 0, 0, sy, 0, 0 )
+    end
+
+    # Public: rotate by angle degrees
+    # 
+    # - angle : rotation in degrees
+    # - cx    : center x
+    # - cy    : center y
+    #
+    # Returns nil
+    #
+    # TODO:
+    # make cx, cy be origin center
+    def rotate( angle, cx=0, cy=0 )
+      a = (angle.to_f/180).to_d * Math::PI
+      translate( cx, cy )
+      transform( Math.cos(a),  Math.sin(a), -Math.sin(a), Math.cos(a), 0, 0)
+      translate( -cx, -cy )
+    end
+
+    def skew_x( angle )
+      a = angle.to_f/180 * Math::PI
+      transform( 1, 0, Math.tan(a), 1, 0, 0 )
+    end
+
+    def skew_y( angle )
+      a = angle.to_f/180 * Math::PI
+      transform( 1, Math.tan(a), 0, 1, 0, 0 )
+    end
+
+    protected
+
+      def transform_dot( dot, a, b, c, d, e, f )
+        x, y  = dot.x, dot.y
+        dot.x = x*a + y*c + e
+        dot.y = x*b + y*d + f
+      end
+
+  end
+end

data/lib/savage/utils.rb

@@ -0,0 +1,7 @@
+module Savage
+  module Utils
+    def bool_to_int(value)
+      (value) ? 1 : 0
+    end
+  end
+end

data/savage-transform.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+Gem::Specification.new do |spec|
+  spec.homepage         = "http://github.com/qhwa/savage"
+  spec.rubygems_version = "2.2.2"
+  spec.summary          = "A little library to manipulate SVG path data. Path commands can be transformed."
+  spec.name             = "savage-transform"
+  spec.version          = "1.3.0"
+  spec.authors          = ["qhwa", "Jeremy Holland"]
+  spec.description      = "A little gem for extracting and manipulating SVG vector path data. Path commands can be transfromed."
+  spec.email            = ["qhwa@163.com", "jeremy@jeremypholland.com"]
+  spec.summary          = %q{extract color information from images}
+  spec.description      = %q{extract color information from images}
+  spec.homepage         = "https://github.com/qhwa/color_extract"
+  spec.license          = "MIT"
+  spec.files            = `git ls-files`.split($/)
+  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_development_dependency "bundler", "~> 1.5"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec", ">= 2.3.0"
+end