geomotion 0.10.0 → 0.12.1

data/lib/geomotion/cg_affine_transform.rb

@@ -0,0 +1,181 @@
+class CGAffineTransform
+  # CGAffineTransform.make  # default transform: identity matrix
+  # # make a transform from scratch
+  # CGAffineTransform.make(a: 1, b: 0, c: 0, d: 1, tx: 0, ty: 0)
+  #
+  # # make a transform using primitives
+  # CGAffineTransform.make(scale: 2, translate: [10, 10], rotate: Math::PI)
+  def self.make(options = {})
+    if options.key?(:a)
+      args = [
+        :a, :b,
+        :c, :d,
+        :tx, :ty,
+      ].map do |key|
+        raise "#{key.inspect} is required" unless options.key? key
+        options[key]
+      end
+      return self.new(*args)
+    else
+      retval = self.identity
+      if options[:translate]
+        retval = retval.translate(options[:translate])
+      end
+      if options[:scale]
+        retval = retval.scale(options[:scale])
+      end
+      if options[:rotate]
+        retval = retval.rotate(options[:rotate])
+      end
+      return retval
+    end
+  end
+
+  # Returns a transform that is translated. Accepts one or two arguments. One
+  # argument can be a Point or Array with two items, two arguments should be the
+  # x and y values.
+  # @return CGAffineTransform
+  def self.translate(point, ty=nil)
+    if ty
+      tx = point
+    else
+      tx = point[0]
+      ty = point[1]
+    end
+    CGAffineTransformMakeTranslation(tx, ty)
+  end
+
+  # Returns a transform that is scaled. Accepts one or two arguments. One
+  # argument can be a Point or Array with two items or a number that will be
+  # used to scale both directions. Two arguments should be the x and y values.
+  def self.scale(scale, sy=nil)
+    if sy
+      sx = scale
+    elsif scale.is_a?(Numeric)
+      sx = sy = scale
+    else
+      sx = scale[0]
+      sy = scale[1]
+    end
+    CGAffineTransformMakeScale(sx, sy)
+  end
+
+  # Returns a transform that is rotated by `angle` (+ => counterclockwise, - => clockwise)
+  # @return CGAffineTransform
+  def self.rotate(angle)
+    CGAffineTransformMakeRotation(angle)
+  end
+
+  # A "shear" translation turns a rectangle into a parallelogram
+  # @param px [Numeric] how much to shear in x direction
+  # @param py [Numeric] how much to shear in y direction
+  # @return CGAffineTransform
+  def self.shear(px, py)
+    CGAffineTransformMake(1, py, px, 1, 0, 0)
+  end
+
+  # Returns the CGAffineTransform identity matrix
+  # @return CGAffineTransform
+  def self.identity
+    CGAffineTransformIdentity
+  end
+
+  # Return true if the receiver is the identity matrix, false otherwise
+  # @return CGAffineTransform
+  def identity?
+    CGAffineTransformIsIdentity(self)
+  end
+
+  # @return [CATransform3D]
+  def to_transform3d
+    CATransform3DMakeAffineTransform(self)
+  end
+
+  # @return [Boolean] true if the two matrices are equal
+  def ==(transform)
+    CGAffineTransformEqualToTransform(self, transform)
+  end
+
+  # Returns self
+  # @return CGAffineTransform
+  def +@
+    self
+  end
+
+  # Concatenates the two transforms
+  # @return CGAffineTransform
+  def concat(transform)
+    CGAffineTransformConcat(self, transform)
+  end
+  alias :+ :concat
+  alias :<< :concat
+
+  # Inverts the transform
+  # @return CGAffineTransform
+  def invert
+    CGAffineTransformInvert(self)
+  end
+  alias :-@ :invert
+
+  # Inverts the second transform and adds the result to `self`
+  # @return CGAffineTransform
+  def -(transform)
+    self.concat transform.invert
+  end
+
+  # Applies a translation transform to the receiver
+  # @return CGAffineTransform
+  def translate(point, ty=nil)
+    if ty
+      tx = point
+    else
+      tx = point[0]
+      ty = point[1]
+    end
+    CGAffineTransformTranslate(self, tx, ty)
+  end
+
+  # Applies a scale transform to the receiver
+  # @return CGAffineTransform
+  def scale(scale, sy=nil)
+    if sy
+      sx = scale
+    elsif scale.is_a?(Numeric)
+      sx = sy = scale
+    else
+      sx = scale[0]
+      sy = scale[1]
+    end
+    CGAffineTransformScale(self, sx, sy)
+  end
+
+  # Applies a rotation transform to the receiver
+  # @return CGAffineTransform
+  def rotate(angle)
+    CGAffineTransformRotate(self, angle)
+  end
+
+  # Applies a shear transform to the receiver
+  # @return CGAffineTransform
+  def shear(px, py)
+    self.concat CGAffineTransform.shear(px, py)
+  end
+
+  def apply_to(thing)
+    case thing
+    when CGPoint
+      CGPointApplyAffineTransform(thing, self)
+    when CGSize
+      CGSizeApplyAffineTransform(thing, self)
+    when CGRect
+      CGRectApplyAffineTransform(thing, self)
+    else
+      raise "Cannot apply transform to #{thing.inspect}"
+    end
+  end
+
+  def to_a
+    [self.a, self.b, self.c, self.d, self.tx, self.ty]
+  end
+
+end

data/lib/geomotion/cg_rect.rb

@@ -9,15 +9,15 @@ class CGRect
   # CGRect.make(origin: point, size: size)
   def self.make(options = {})
     if options[:origin]
-      x = options[:origin].x
-      y = options[:origin].y
+      x = options[:origin][0]
+      y = options[:origin][1]
     else
       x = options[:x] || 0
       y = options[:y] || 0
     end
     if options[:size]
-      w = options[:size].width
-      h = options[:size].height
+      w = options[:size][0]
+      h = options[:size][1]
     else
       w = options[:width] || 0
       h = options[:height] || 0

data/lib/geomotion/version.rb

@@ -1,3 +1,3 @@
 module Geomotion
-  VERSION = "0.10.0"
+  VERSION = "0.12.1"
 end

data/spec/ca_transform_3d_spec.rb

@@ -0,0 +1,345 @@
+describe "CATransform3D" do
+
+  describe "operations" do
+
+    it "should support ==" do
+      CATransform3D.make(
+        m11: 1, m12: 0, m13: 0, m14: 0,
+        m21: 0, m22: 1, m23: 0, m24: 0,
+        m31: 0, m32: 0, m33: 1, m34: 0,
+        m41: 0, m42: 0, m43: 0, m44: 1,
+      ).should == CATransform3D.make(
+        m11: 1, m12: 0, m13: 0, m14: 0,
+        m21: 0, m22: 1, m23: 0, m24: 0,
+        m31: 0, m32: 0, m33: 1, m34: 0,
+        m41: 0, m42: 0, m43: 0, m44: 1,
+      )
+    end
+
+    it "should support +" do
+      t1 = CATransform3D.make(
+        m11: 2, m12: 0, m13: 0, m14: 0,
+        m21: 0, m22: 2, m23: 0, m24: 0,
+        m31: 0, m32: 0, m33: 2, m34: 0,
+        m41: 0, m42: 0, m43: 0, m44: 1,
+        )
+      t2 = CATransform3D.make(
+        m11: 1, m12: 0, m13: 0, m14: 0,
+        m21: 0, m22: 1, m23: 0, m24: 0,
+        m31: 0, m32: 0, m33: 1, m34: 0,
+        m41: 1, m42: 2, m43: 3, m44: 1,
+        )
+      (t1 + t2).should == CATransform3D.make(
+        m11: 2, m12: 0, m13: 0, m14: 0,
+        m21: 0, m22: 2, m23: 0, m24: 0,
+        m31: 0, m32: 0, m33: 2, m34: 0,
+        m41: 1, m42: 2, m43: 3, m44: 1,
+        )
+    end
+
+    it "should support <<" do
+      t1 = CATransform3D.make(
+        m11: 2, m12: 0, m13: 0, m14: 0,
+        m21: 0, m22: 2, m23: 0, m24: 0,
+        m31: 0, m32: 0, m33: 2, m34: 0,
+        m41: 0, m42: 0, m43: 0, m44: 1,
+        )
+      t2 = CATransform3D.make(
+        m11: 1, m12: 0, m13: 0, m14: 0,
+        m21: 0, m22: 1, m23: 0, m24: 0,
+        m31: 0, m32: 0, m33: 1, m34: 0,
+        m41: 1, m42: 2, m43: 3, m44: 1,
+        )
+      (t1 << t2).should == CATransform3D.make(
+        m11: 2, m12: 0, m13: 0, m14: 0,
+        m21: 0, m22: 2, m23: 0, m24: 0,
+        m31: 0, m32: 0, m33: 2, m34: 0,
+        m41: 1, m42: 2, m43: 3, m44: 1,
+        )
+    end
+
+    it "should support -" do
+      t1 = CATransform3D.make(
+        m11: 2, m12: 0, m13: 0, m14: 0,
+        m21: 0, m22: 2, m23: 0, m24: 0,
+        m31: 0, m32: 0, m33: 2, m34: 0,
+        m41: 0, m42: 0, m43: 0, m44: 1,
+        )
+      t2 = CATransform3D.make(
+        m11: 1, m12: 0, m13: 0, m14: 0,
+        m21: 0, m22: 1, m23: 0, m24: 0,
+        m31: 0, m32: 0, m33: 1, m34: 0,
+        m41: 1, m42: 2, m43: 3, m44: 1,
+        )
+      (t1 - t2).should == CATransform3D.make(
+        m11: 2, m12: 0, m13: 0, m14: 0,
+        m21: 0, m22: 2, m23: 0, m24: 0,
+        m31: 0, m32: 0, m33: 2, m34: 0,
+        m41: -1, m42: -2, m43: -3, m44: 1,
+        )
+    end
+
+    it "subtracting itself should return identity (scale)" do
+      t1 = CATransform3D.make(
+        m11: 2, m12: 0, m13: 0, m14: 0,
+        m21: 0, m22: 2, m23: 0, m24: 0,
+        m31: 0, m32: 0, m33: 2, m34: 0,
+        m41: 0, m42: 0, m43: 0, m44: 1,
+        )
+      (t1 - t1).should == CATransform3D.make(
+        m11: 1, m12: 0, m13: 0, m14: 0,
+        m21: 0, m22: 1, m23: 0, m24: 0,
+        m31: 0, m32: 0, m33: 1, m34: 0,
+        m41: 0, m42: 0, m43: 0, m44: 1,
+        )
+    end
+
+    it "subtracting itself should return identity (translate)" do
+      t1 = CATransform3D.make(
+        m11: 1, m12: 0, m13: 0, m14: 0,
+        m21: 0, m22: 1, m23: 0, m24: 0,
+        m31: 0, m32: 0, m33: 1, m34: 0,
+        m41: 1, m42: 2, m43: 3, m44: 1,
+        )
+      (t1 - t1).should == CATransform3D.make(
+        m11: 1, m12: 0, m13: 0, m14: 0,
+        m21: 0, m22: 1, m23: 0, m24: 0,
+        m31: 0, m32: 0, m33: 1, m34: 0,
+        m41: 0, m42: 0, m43: 0, m44: 1,
+        )
+    end
+
+    it "subtracting itself should return identity (rotate)" do
+      t1 = CATransform3D.make(
+        m11:-1, m12: 0, m13: 0, m14: 0,
+        m21: 0, m22:-1, m23: 0, m24: 0,
+        m31: 0, m32: 0, m33: 1, m34: 0,
+        m41: 0, m42: 0, m43: 0, m44: 1,
+        )
+      (t1 - t1).should == CATransform3D.make(
+        m11: 1, m12: 0, m13: 0, m14: 0,
+        m21: 0, m22: 1, m23: 0, m24: 0,
+        m31: 0, m32: 0, m33: 1, m34: 0,
+        m41: 0, m42: 0, m43: 0, m44: 1,
+        )
+    end
+
+    it "should support unary -" do
+      (- CATransform3D.make(
+        m11: 1, m12: 0, m13: 0, m14: 0,
+        m21: 0, m22: 1, m23: 0, m24: 0,
+        m31: 0, m32: 0, m33: 1, m34: 0,
+        m41: 1, m42: 2, m43: 3, m44: 1,
+      )).should == CATransform3D.make(
+        m11: 1, m12: 0, m13: 0, m14: 0,
+        m21: 0, m22: 1, m23: 0, m24: 0,
+        m31: 0, m32: 0, m33: 1, m34: 0,
+        m41:-1, m42:-2, m43:-3, m44: 1,
+      )
+    end
+
+    it "should support unary +" do
+      (+ CATransform3D.make(
+        m11: 1, m12: 0, m13: 0, m14: 0,
+        m21: 0, m22: 1, m23: 0, m24: 0,
+        m31: 0, m32: 0, m33: 1, m34: 0,
+        m41: 1, m42: 2, m43: 3, m44: 1,
+      )).should == CATransform3D.make(
+        m11: 1, m12: 0, m13: 0, m14: 0,
+        m21: 0, m22: 1, m23: 0, m24: 0,
+        m31: 0, m32: 0, m33: 1, m34: 0,
+        m41: 1, m42: 2, m43: 3, m44: 1,
+      )
+    end
+
+  end
+
+  describe ".make" do
+
+    it "should work with no arguments" do
+      transform = CATransform3D.make
+      transform.should == CATransform3D.identity
+    end
+
+    it "should work with options" do
+      transform = CATransform3D.make(
+        m11: 1, m12: 0, m13: 0, m14: 0,
+        m21: 0, m22: 1, m23: 0, m24: 0,
+        m31: 0, m32: 0, m33: 1, m34: 0,
+        m41: 0, m42: 0, m43: 0, m44: 1,
+        )
+      CATransform3DIsIdentity(transform).should == true
+    end
+
+    it "should work with transform options (scale)" do
+      CATransform3D.make(scale: [2, 3, 4]).should == CATransform3D.new(2,0,0,0 ,0,3,0,0 ,0,0,4,0 ,0,0,0,1)
+    end
+
+    it "should work with transform options (translate)" do
+      CATransform3D.make(translate: [10, 20, 30]).should == CATransform3D.new(1,0,0,0 ,0,1,0,0 ,0,0,1,0 ,10,20,30,1)
+    end
+
+    it "should work with transform options (rotate)" do
+      transform = CATransform3D.make(rotate: Math::PI).to_a.map { |v| v.round(3) }
+      CATransform3D.new(*transform).should == CATransform3D.new(-1,0,0,0 ,0,-1,0,0 ,0,0,1,0 ,0,0,0,1)
+    end
+
+    it "should work with transform options (scale + translate)" do
+      CATransform3D.make(scale: [2, 3, 4], translate: [10, 20, 30]).should == CATransform3D.new(2,0,0,0 ,0,3,0,0 ,0,0,4,0 ,10,20,30,1)
+    end
+
+    it "should work with transform options (scale + translate + rotation)" do
+      transform = CATransform3D.make(scale: [2, 3, 4], rotate: Math::PI, translate: [10, 20, 30]).to_a.map { |v| v.round(3) }
+      CATransform3D.new(*transform).should == CATransform3D.new(-2,0,0,0 ,0,-3,0,0 ,0,0,4,0 ,10,20,30,1)
+    end
+
+  end
+
+  describe "identity" do
+
+    it "should return the identity matrix" do
+      CATransform3DIsIdentity(CATransform3D.identity).should == true
+    end
+
+    it "identity? should return true for identity matrix" do
+      CATransform3D.identity.identity?.should == true
+    end
+
+    it "identity? should return false other matrices" do
+      CATransform3D.scale(2).identity?.should == false
+    end
+
+  end
+
+  describe ".rotate" do
+
+    it "should work as a factory (x-axis)" do
+      transform = CATransform3D.rotate(Math::PI, 1, 0, 0).to_a.map { |v| v.round(3) }
+      CATransform3D.new(*transform).should == CATransform3D.new(1,0,0,0, 0,-1,0,0, 0,0,-1,0, 0,0,0,1)
+    end
+
+    it "should work as a factory (y-axis)" do
+      transform = CATransform3D.rotate(Math::PI, 0, 1, 0).to_a.map { |v| v.round(3) }
+      CATransform3D.new(*transform).should == CATransform3D.new(-1,0,0,0, 0,1,0,0, 0,0,-1,0, 0,0,0,1)
+    end
+
+    it "should work as a factory (z-axis)" do
+      transform = CATransform3D.rotate(Math::PI, 0, 0, 1).to_a.map { |v| v.round(3) }
+      CATransform3D.new(*transform).should == CATransform3D.new(-1,0,0,0 ,0,-1,0,0 ,0,0,1,0 ,0,0,0,1)
+    end
+
+    it "should work as a factory (default)" do
+      transform = CATransform3D.rotate(Math::PI).to_a.map { |v| v.round(3) }
+      CATransform3D.new(*transform).should == CATransform3D.new(-1,0,0,0 ,0,-1,0,0 ,0,0,1,0 ,0,0,0,1)
+    end
+
+    it "should work as an instance method (x-axis)" do
+      transform = CATransform3D.identity.rotate(Math::PI, 1, 0, 0).to_a.map { |v| v.round(3) }
+      CATransform3D.new(*transform).should == CATransform3D.new(1,0,0,0, 0,-1,0,0, 0,0,-1,0, 0,0,0,1)
+    end
+
+    it "should work as an instance method (y-axis)" do
+      transform = CATransform3D.identity.rotate(Math::PI, 0, 1, 0).to_a.map { |v| v.round(3) }
+      CATransform3D.new(*transform).should == CATransform3D.new(-1,0,0,0, 0,1,0,0, 0,0,-1,0, 0,0,0,1)
+    end
+
+    it "should work as an instance method (z-axis)" do
+      transform = CATransform3D.identity.rotate(Math::PI, 0, 0, 1).to_a.map { |v| v.round(3) }
+      CATransform3D.new(*transform).should == CATransform3D.new(-1,0,0,0 ,0,-1,0,0 ,0,0,1,0 ,0,0,0,1)
+    end
+
+    it "should work as an instance method (default)" do
+      transform = CATransform3D.identity.rotate(Math::PI).to_a.map { |v| v.round(3) }
+      CATransform3D.new(*transform).should == CATransform3D.new(-1,0,0,0 ,0,-1,0,0 ,0,0,1,0 ,0,0,0,1)
+    end
+
+  end
+
+  describe ".scale" do
+
+    it "should work as a factory with one argument" do
+      CATransform3D.scale(2).should == CATransform3D.new(2,0,0,0 ,0,2,0,0 ,0,0,1,0 ,0,0,0,1)
+    end
+
+    it "should work as a factory with three arguments" do
+      CATransform3D.scale(2, 3, 4).should == CATransform3D.new(2,0,0,0 ,0,3,0,0 ,0,0,4,0 ,0,0,0,1)
+    end
+
+    it "should work as a factory with one array" do
+      CATransform3D.scale([2, 3, 4]).should == CATransform3D.new(2,0,0,0 ,0,3,0,0 ,0,0,4,0 ,0,0,0,1)
+    end
+
+    it "should work as an instance method with one argument" do
+      CATransform3D.identity.scale(2).should == CATransform3D.new(2,0,0,0 ,0,2,0,0 ,0,0,1,0 ,0,0,0,1)
+    end
+
+    it "should work as an instance method with three arguments" do
+      CATransform3D.identity.scale(2, 3, 4).should == CATransform3D.new(2,0,0,0 ,0,3,0,0 ,0,0,4,0 ,0,0,0,1)
+    end
+
+    it "should work as an instance method with one array" do
+      CATransform3D.identity.scale([2, 3, 4]).should == CATransform3D.new(2,0,0,0 ,0,3,0,0 ,0,0,4,0 ,0,0,0,1)
+    end
+
+  end
+
+  describe ".translate" do
+
+    it "should work as a factory with three arguments" do
+      CATransform3D.translate(10, 20, 30).should == CATransform3D.new(1,0,0,0 ,0,1,0,0 ,0,0,1,0 ,10,20,30,1)
+    end
+
+    it "should work as a factory with one array" do
+      CATransform3D.translate([10, 20, 30]).should == CATransform3D.new(1,0,0,0 ,0,1,0,0 ,0,0,1,0 ,10,20,30,1)
+    end
+
+    it "should work as an instance method with three arguments" do
+      CATransform3D.identity.translate(10, 20, 30).should == CATransform3D.new(1,0,0,0 ,0,1,0,0 ,0,0,1,0 ,10,20,30,1)
+    end
+
+    it "should work as an instance method with one array" do
+      CATransform3D.identity.translate([10, 20, 30]).should == CATransform3D.new(1,0,0,0 ,0,1,0,0 ,0,0,1,0 ,10,20,30,1)
+    end
+
+  end
+
+  describe ".perspective" do
+
+    it "should work as a factory with two arguments" do
+      CATransform3D.perspective(0.002, 0).should == CATransform3D.new(1,0,0,0.002, 0,1,0,0, 0,0,1,0, 0,0,0,1)
+      CATransform3D.perspective(0, 0.002).should == CATransform3D.new(1,0,0,0, 0,1,0,0.002, 0,0,1,0, 0,0,0,1)
+    end
+
+    it "should work as an instance method with two arguments" do
+      CATransform3D.identity.perspective(0.002, 0).should == CATransform3D.new(1,0,0,0.002, 0,1,0,0, 0,0,1,0, 0,0,0,1)
+      CATransform3D.identity.perspective(0, 0.002).should == CATransform3D.new(1,0,0,0, 0,1,0,0.002, 0,0,1,0, 0,0,0,1)
+    end
+
+  end
+
+  describe "other methods" do
+
+    it "should support concat" do
+      t1 = CATransform3D.translate(10, 20, 30)
+      t2 = CATransform3D.scale(2)
+      t1.concat(t2).should == CATransform3D.new(2,0,0,0 ,0,2,0,0 ,0,0,1,0 ,20,40,30,1)
+    end
+
+    it "should support invert" do
+      t1 = CATransform3D.scale(2)
+      t1.invert.should == CATransform3D.new(0.5,0,0,0 ,0,0.5,0,0 ,0,0,1,0 ,0,0,0,1)
+    end
+
+    it "should support to_affine_transform" do
+      t1 = CATransform3D.new(2,0,0,0 ,0,2,0,0 ,0,0,2,0 ,0,0,0,1)
+      t1.to_affine_transform.should == CGAffineTransformMake(2, 0, 0, 2, 0, 0)
+    end
+
+    it 'should support to_a' do
+      t1 = CATransform3D.identity
+      t1.to_a.should == [1,0,0,0 ,0,1,0,0 ,0,0,1,0 ,0,0,0,1]
+    end
+
+  end
+
+end