geo3d 0.0.5 → 0.0.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8af038ca077d7a6bdfd933b9486cf4a63ab8a73f
-  data.tar.gz: 75bb46be5985112547d52bcdfb06046c651ba2af
+  metadata.gz: d8f3862b698223418bf989a4cce3c0dc45c74aec
+  data.tar.gz: 8df829279ef53a7003215b5aeb18c3a4127af036
 SHA512:
-  metadata.gz: 81c47c990a4c186edb1c07d632f1c287d3854686ab589e071f6a496733d08b8c04929989ee473c7a08d91b5451e6cc1583311604cf87e4fb859a998b7c31b216
-  data.tar.gz: 2799ed1ff5754f41b74ce781105c68a5ba864661346d36967012be1ca5cdbeebf8411b726713ea0ed95e3d23b4aaf845788de786c892157a13f64b1007c8a67f
+  metadata.gz: ef96a2ee15de30cc29f298cac21258a45c764d8895837525b172280973f89bf905ef7ceb5af4240471b5894c890e57aed57856e2c8337aca7472a47411462e66
+  data.tar.gz: 79c5f1a2776f2647d139f7de64f4fcc148a242bfe0bf9e9c0db3ba0357cda31d522114da94adf2cfd20581080028b36577c67bc814296b36c0d8428a93552518

data/README.md

@@ -179,23 +179,71 @@ Matrix Decomposition
 
 A mathematical construct to represent rotations in 3d space.
 
+Quaternions support all the basic math operations.
+
+Addition
+```
+    quat_a + quat_b
+```
+Subtraction
+```
+    quat_a - quat_b
+```
 Quaternion Multiplication
 ```
     quat_a * quat_b
 ```
+Scalar Multiplication
+```
+    quat * scalar
+```
+Scalar Division
+```
+    quat / scalar
+```
 Getting axis and angle
 ```
     quat.axis
-    quat.angle
+    quat.angle          #returns angle in radians
+    quat.angle_degrees  #returns angle in degrees
 ```
 Converting to a matrix
 ```
     quat.to_matrix
 ```
+
+Additional quaternion operations
+Magnitude
+```
+    quat.length
+```
+Squared Magnitude
+```
+    quat.length_squared
+```
+Normalize
+```
+    quat.normalize #returns a normalized version of the quaternion
+    quat.normalize! #normalizes the quaternion in place
+```
+Inverse
+```
+    quat.inverse #returns inverse of quaternion
+```
+Conjugate
+```
+    quat.conjugate
+```
+Dot product
+```
+    quat.dot
+```
+
 Constructors
 ```
     Geo3d::Quaternion.from_axis rotation_axis, radians  #returns a quaternion from an axis and angle
     Geo3d::Quaternion.from_matrix m  #returns a quaternion from a rotation matrix
+    Geo3d::Quaternion.identity  #returns the identity quaternion
 
 ```
 

data/Rakefile

@@ -1 +1,8 @@
 require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new
+
+task :default => :spec
+task :test => :spec
+

data/geo3d.gemspec

@@ -20,4 +20,5 @@ Gem::Specification.new do |spec|
 
   spec.add_development_dependency "bundler", "~> 1.3"
   spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
 end

data/lib/geo3d.rb

@@ -2,5 +2,6 @@ require 'geo3d/version'
 require 'vector'
 require 'matrix'
 require 'quaternion'
+require 'plane'
 
 

data/lib/geo3d/version.rb

@@ -1,3 +1,3 @@
 module Geo3d
-  VERSION = "0.0.5"
+  VERSION = "0.0.6"
 end

data/lib/matrix.rb

@@ -54,6 +54,32 @@ module Geo3d
       send (%w{_11 _12 _13 _14 _21 _22 _23 _24 _31 _32 _33 _34 _41 _42 _43 _44}[4*x + y] + '=').to_sym, v
     end
 
+    def row i
+      if i >= 0 && i <= 3
+        Vector.new self[0, i], self[1, i], self[2, i], self[3, i]
+      end
+    end
+
+    def col i
+      if i >= 0 && i <= 3
+        Vector.new self[i, 0], self[i, 1], self [i, 2], self[i, 3]
+      end
+    end
+
+    def set_row i, v
+      self[0, i] = v.x
+      self[1, i] = v.y
+      self[2, i] = v.z
+      self[3, i] = v.w
+    end
+
+    def set_col i, v
+      self[i, 0] = v.x
+      self[i, 1] = v.y
+      self[i, 2] = v.z
+      self[i, 3] = v.w
+    end
+
     def == m
       a = to_a
       b = m.to_a
@@ -155,10 +181,10 @@ module Geo3d
       elsif Vector == v.class
         vec = v
         transformed_vector = Vector.new
-        transformed_vector.x = _11 * vec.x + _21 * vec.y + _31 * vec.z + _41
-        transformed_vector.y = _12 * vec.x + _22 * vec.y + _32 * vec.z + _42
-        transformed_vector.z = _13 * vec.x + _23 * vec.y + _33 * vec.z + _43
-        transformed_vector.w = _14 * vec.x + _24 * vec.y + _34 * vec.z + _44
+        transformed_vector.x = _11 * vec.x + _21 * vec.y + _31 * vec.z + _41 * vec.w
+        transformed_vector.y = _12 * vec.x + _22 * vec.y + _32 * vec.z + _42 * vec.w
+        transformed_vector.z = _13 * vec.x + _23 * vec.y + _33 * vec.z + _43 * vec.w
+        transformed_vector.w = _14 * vec.x + _24 * vec.y + _34 * vec.z + _44 * vec.w
         return transformed_vector
       else
         scalar = v
@@ -212,12 +238,7 @@ module Geo3d
     end
 
     def transform_coord vec
-      norm =_14 * vec.x + _24 * vec.y + _34 * vec.z + _44
-      transformed_vector = self * vec
-      transformed_vector.x /= norm
-      transformed_vector.y /= norm
-      transformed_vector.z /= norm
-      transformed_vector
+      self * Vector.new( vec.x, vec.y, vec.z, 1.0 )
     end
 
     def transform vec
@@ -348,9 +369,9 @@ module Geo3d
 
 
       # calculate matrix inverse
-      det = 1.0/det
+      inverse_det = 1.0/det
       for j in 0..15
-        dst[j] *= det
+        dst[j] *= inverse_det
       end
 
       inverted_matrix = self.class.new *dst
@@ -402,6 +423,10 @@ module Geo3d
       puts "_44: #{_44}\n"
     end
 
+    def to_s
+      (0..3).to_a.map{ |i| row(i).to_s}.join "\n"
+    end
+
     def self.perspective_fov_rh fovy, aspect, zn, zf
       fovy = fovy.to_f
       aspect = aspect.to_f
@@ -533,6 +558,7 @@ module Geo3d
     end
 
     def self.reflection reflection_plane
+      reflection_plane = Geo3d::Vector.new *reflection_plane.to_a
       reflection_matrix = self.new
 
       plane_magnitude = Vector.new(reflection_plane.x, reflection_plane.y, reflection_plane.z, 0).length
@@ -566,6 +592,7 @@ module Geo3d
     end
 
     def self.shadow light_position, plane
+      plane = Geo3d::Vector.new *plane.to_a
       norm = plane.x * plane.x + plane.y * plane.y + plane.z * plane.z
       normalized_plane = plane / norm
       dot = normalized_plane.dot(light_position)

data/lib/plane.rb

@@ -0,0 +1,95 @@
+module Geo3d
+  class Plane
+    attr_accessor :a, :b, :c, :d
+    alias :x :a
+    alias :y :b
+    alias :z :c
+    alias :w :d
+
+    def initialize *args
+      @a = 0.0
+      @b = 0.0
+      @c = 0.0
+      @d = 0.0
+      @a = args[0].to_f if args.size > 0
+      @b = args[1].to_f if args.size > 1
+      @c = args[2].to_f if args.size > 2
+      @d = args[3].to_f if args.size > 3
+    end
+
+    def self.from_points pv1, pv2, pv3
+      edge1 = pv2 - pv1
+      edge2 = pv3 - pv1
+      from_point_and_normal pv1, edge1.cross(edge2).normalize
+    end
+
+    def self.from_point_and_normal point, normal
+      point.w = 0
+      self.new normal.x, normal.y, normal.z, -point.dot(normal)
+    end
+
+    def to_a
+      [a,b,c,d]
+    end
+
+    def == p
+       Geo3d::Utils.float_cmp(a, p.a) && Geo3d::Utils.float_cmp(b, p.b) && Geo3d::Utils.float_cmp(c, p.c) && Geo3d::Utils.float_cmp(d, p.d)
+     end
+
+     def != vec
+       !(self == vec)
+     end
+
+    def dot v
+      a * v.x + b * v.y + c * v.z + d * v.w
+    end
+
+    def normalize!
+      norm = Math.sqrt(a*a + b*b + c*c)
+      if norm.zero?
+        @a = 0
+        @b = 0
+        @c = 0
+        @d = 0
+      else
+        @a /= norm
+        @b /= norm
+        @c /= norm
+        @d /= norm
+      end
+    end
+
+    def normalize
+      p = self.class.new a, b, c, d
+      p.normalize!
+      p
+    end
+
+    def normal
+      Vector.new a, b, c
+    end
+
+    def line_intersection line_start, line_end
+      direction = line_end - line_start
+
+      normal_dot_direction = normal.dot direction
+
+      if (normal_dot_direction.zero?)
+        nil
+      else
+        temp = (d + normal.dot(line_start)) / normal_dot_direction
+        line_start - direction * temp
+      end
+    end
+
+    def transform matrix, use_inverse_transpose = true
+      matrix = matrix.inverse.transpose if use_inverse_transpose
+      p = self.class.new
+      p.a = dot matrix.row(0)
+      p.b = dot matrix.row(1)
+      p.c = dot matrix.row(2)
+      p.d = dot matrix.row(3)
+      p
+    end
+  end
+end

data/lib/quaternion.rb

@@ -46,9 +46,7 @@ module Geo3d
     end
 
     def self.from_axis rotation_axis, radians = 0
-      normalized_rotation_axis = rotation_axis.normalize
-      #const float radians = GeoConvertToRadians( degrees );
-
+      normalized_rotation_axis = rotation_axis.zero_w.normalize
       q = self.new
       q.x = Math.sin(radians / 2.0) * normalized_rotation_axis.x
       q.y = Math.sin(radians / 2.0) * normalized_rotation_axis.y
@@ -70,6 +68,8 @@ module Geo3d
         pout.y = (pm._31 - pm._13) / (2.0 * Math.sqrt(trace))
         pout.z = (pm._12- pm._21) / (2.0 * Math.sqrt(trace))
         pout.w = Math.sqrt(trace) / 2.0
+        puts "a and pout is #{pout.inspect}"
+
         return pout
       end
       maxi = 0
@@ -104,6 +104,7 @@ module Geo3d
           pout.z = 0.25 * s
           pout.w = (pm._12 - pm._21) / s
       end
+      puts "b"
       pout
     end
 
@@ -134,7 +135,7 @@ module Geo3d
     end
 
     def to_matrix
-      v = Vector.new(x, y, z, w); ## Normalize();
+      v = normalize
       matrix = Matrix.identity
       matrix._11 = 1.0 - 2.0 * (v.y * v.y + v.z * v.z)
       matrix._12 = 2.0 * (v.x * v.y + v.z * v.w)

data/lib/vector.rb

@@ -17,6 +17,14 @@ module Geo3d
       @w = args[3].to_f if args.size > 3
     end
 
+    def zero_w
+      self.class.new x, y, z, 0
+    end
+
+    def one_w
+      self.class.new x, y, z, 1
+    end
+
     def to_s
       to_a.compact.join ' '
     end

data/spec/lib/matrix_spec.rb

@@ -0,0 +1,227 @@
+require 'spec_helper'
+
+describe Geo3d::Matrix do
+  def random_matrix
+    r = Geo3d::Matrix.new
+    for i in 0..3
+      for j in 0..3
+        r[i, j] = rand 10000
+      end
+    end
+    r
+  end
+
+  def random_vector
+    v = Geo3d::Vector.new
+    v.x = rand 10000
+    v.y = rand 10000
+    v.z = rand 10000
+    v.w = rand 10000
+    v
+  end
+
+
+  it "should default all values to zero" do
+    Geo3d::Matrix.new.to_a.select(&:zero?).size.should == 16
+  end
+
+  it "should be able to extract translation component" do
+
+  end
+
+  it "should be able to extract scaling component" do
+
+  end
+
+  it "should be able to extract rotation component" do
+
+  end
+
+  it "should be invertible" do
+    100.times do
+      r = random_matrix
+      (r * r.inverse).identity?.should == true
+    end
+  end
+
+  it "should return the determinant" do
+    [{:matrix => [0.321046, 0.000000, 0.000000, 0.000000, 0.000000, 0.642093, 0.000000, 0.000000, 0.000000, 0.000000, -1.000095, -1.000000, 0.000000, 0.000000, -2.000190, 0.000000], :expected => -0.412322},
+     {:matrix => [1.000000, 0.000000, 0.000000, 0.000000, 0.000000, -1.000000, 0.000000, 0.000000, 0.000000, 0.000000, 1.000000, 0.000000, 0.000000, -2.000000, 0.000000, 1.000000], :expected => -1},
+     {:matrix => [-0.392804, -0.878379, -0.272314, 0.000000, 0.000000, 0.296115, -0.955152, 0.000000, 0.919622, -0.375187, -0.116315, 0.000000, -2.366064, 1.411711, 2.531564, 1.000000], :expected => 1}].each do |data|
+      data[:matrix].size.should == 16
+      Geo3d::Utils.float_cmp( Geo3d::Matrix.new(*data[:matrix]).determinant, data[:expected] ).should == true
+    end
+  end
+
+  it "should be transposable" do
+
+  end
+
+  it "should have an identity constructor" do
+    identity = Geo3d::Matrix.identity
+    identity.identity?.should == true
+  end
+
+  it "should have a right handed perspective projection constructor" do
+    [{:fovy => 2, :aspect => 2, :zn => 2, :zf => 21000, :expected => [0.321046, 0.000000, 0.000000, 0.000000, 0.000000, 0.642093, 0.000000, 0.000000, 0.000000, 0.000000, -1.000095, -1.000000, 0.000000, 0.000000, -2.000190, 0.000000]}].each do |data|
+      matrix = Geo3d::Matrix.perspective_fov_rh data[:fovy], data[:aspect], data[:zn], data[:zf]
+      data[:expected].size.should == 16
+      expected = Geo3d::Matrix.new *data[:expected]
+      matrix.should == expected
+    end
+  end
+
+
+  it "should have a left handed perspective projection constructor" do
+    [{:fovy => 2, :aspect => 2, :zn => 2, :zf => 21000, :expected => [0.321046, 0.000000, 0.000000, 0.000000, 0.000000, 0.642093, 0.000000, 0.000000, 0.000000, 0.000000, 1.000095, 1.000000, 0.000000, 0.000000, -2.000190, 0.000000]}].each do |data|
+      matrix = Geo3d::Matrix.perspective_fov_lh data[:fovy], data[:aspect], data[:zn], data[:zf]
+      data[:expected].size.should == 16
+      expected = Geo3d::Matrix.new *data[:expected]
+      matrix.should == expected
+    end
+  end
+
+
+  it "should have a right handed orthographic projection constructor" do
+    [{:l => -100, :r => 100, :b => -200, :t => 200, :zn => 1, :zf => 2000, :expected => [0.010000, 0.000000, 0.000000, 0.000000, 0.000000, 0.005000, 0.000000, 0.000000, 0.000000, 0.000000, -0.000500, 0.000000, -0.000000, -0.000000, -0.000500, 1.000000]}].each do |data|
+      matrix = Geo3d::Matrix.ortho_off_center_rh data[:l], data[:r], data[:b], data[:t], data[:zn], data[:zf]
+      data[:expected].size.should == 16
+      expected = Geo3d::Matrix.new *data[:expected]
+      matrix.should == expected
+    end
+  end
+
+
+  it "should have a left handed orthographic projection constructor" do
+    [{:l => -100, :r => 100, :b => -200, :t => 200, :zn => 1, :zf => 2000, :expected => [0.010000, 0.000000, 0.000000, 0.000000, 0.000000, 0.005000, 0.000000, 0.000000, 0.000000, 0.000000, 0.000500, 0.000000, -0.000000, -0.000000, -0.000500, 1.000000]}].each do |data|
+      matrix = Geo3d::Matrix.ortho_off_center_lh data[:l], data[:r], data[:b], data[:t], data[:zn], data[:zf]
+      data[:expected].size.should == 16
+      expected = Geo3d::Matrix.new *data[:expected]
+      matrix.should == expected
+    end
+  end
+
+
+  it "should have a right handed view constructor" do
+    [{:eye => [1, 2, 3], :focus => [200, 700, 88], :up => [0, 1, 0], :expected => [-0.392804, -0.878379, -0.272314, 0.000000, 0.000000, 0.296115, -0.955152, 0.000000, 0.919622, -0.375187, -0.116315, 0.000000, -2.366064, 1.411711, 2.531564, 1.000000]}].each do |data|
+      matrix = Geo3d::Matrix.look_at_rh Geo3d::Vector.new(*data[:eye]), Geo3d::Vector.new(*data[:focus]), Geo3d::Vector.new(*data[:up])
+      data[:expected].size.should == 16
+      expected = Geo3d::Matrix.new *data[:expected]
+      matrix.should == expected
+    end
+  end
+
+
+  it "should have a left handed view constructor" do
+    [{:eye => [1, 2, 3], :focus => [200, 700, 88], :up => [0, 1, 0], :expected => [0.392804, -0.878379, 0.272314, 0.000000, 0.000000, 0.296115, 0.955152, 0.000000, -0.919622, -0.375187, 0.116315, 0.000000, 2.366064, 1.411711, -2.531564, 1.000000]}].each do |data|
+      matrix = Geo3d::Matrix.look_at_lh Geo3d::Vector.new(*data[:eye]), Geo3d::Vector.new(*data[:focus]), Geo3d::Vector.new(*data[:up])
+      data[:expected].size.should == 16
+      expected = Geo3d::Matrix.new *data[:expected]
+      matrix.should == expected
+    end
+  end
+
+  it "should have a translation constructor" do
+    10.times do
+      random_translation = random_vector
+      matrix = Geo3d::Matrix.translation random_translation.x, random_translation.y, random_translation.z
+      10.times do
+        random_vec = random_vector.one_w
+        Geo3d::Utils.float_cmp((matrix * random_vec).x, random_vec.x + random_translation.x).should == true
+        Geo3d::Utils.float_cmp((matrix * random_vec).y, random_vec.y + random_translation.y).should == true
+        Geo3d::Utils.float_cmp((matrix * random_vec).z, random_vec.z + random_translation.z).should == true
+        Geo3d::Utils.float_cmp((matrix * random_vec).w, 1).should == true
+      end
+    end
+  end
+
+  it "should have a scaling constructor" do
+    10.times do
+      random_scaling = random_vector
+      matrix = Geo3d::Matrix.scaling random_scaling.x, random_scaling.y, random_scaling.z
+      10.times do
+        random_vec = random_vector.one_w
+        Geo3d::Utils.float_cmp((matrix * random_vec).x, random_vec.x * random_scaling.x).should == true
+        Geo3d::Utils.float_cmp((matrix * random_vec).y, random_vec.y * random_scaling.y).should == true
+        Geo3d::Utils.float_cmp((matrix * random_vec).z, random_vec.z * random_scaling.z).should == true
+        Geo3d::Utils.float_cmp((matrix * random_vec).w, 1).should == true
+      end
+    end
+  end
+
+
+  it "should have an x-axis rotation constructor" do
+    [{:angle => 1, :expected => [1.000000, 0.000000, 0.000000, 0.000000, 0.000000, 0.540302, 0.841471, 0.000000, 0.000000, -0.841471, 0.540302, 0.000000, 0.000000, 0.000000, 0.000000, 1.000000]},
+     {:angle => 3.2, :expected => [1.000000, 0.000000, 0.000000, 0.000000, 0.000000, -0.998295, -0.058374, 0.000000, 0.000000, 0.058374, -0.998295, 0.000000, 0.000000, 0.000000, 0.000000, 1.000000]}].each do |data|
+      matrix = Geo3d::Matrix.rotation_x data[:angle]
+      data[:expected].size.should == 16
+      expected = Geo3d::Matrix.new *data[:expected]
+      matrix.should == expected
+    end
+  end
+
+  it "should have an y-axis rotation constructor" do
+    [{:angle => 1, :expected => [0.540302, 0.000000, -0.841471, 0.000000, 0.000000, 1.000000, 0.000000, 0.000000, 0.841471, 0.000000, 0.540302, 0.000000, 0.000000, 0.000000, 0.000000, 1.000000]},
+     {:angle => 3.2, :expected => [-0.998295, 0.000000, 0.058374, 0.000000, 0.000000, 1.000000, 0.000000, 0.000000, -0.058374, 0.000000, -0.998295, 0.000000, 0.000000, 0.000000, 0.000000, 1.000000]}].each do |data|
+      matrix = Geo3d::Matrix.rotation_y data[:angle]
+      data[:expected].size.should == 16
+      expected = Geo3d::Matrix.new *data[:expected]
+      matrix.should == expected
+    end
+  end
+
+  it "should have a z-axis rotation constructor" do
+    [{:angle => 1, :expected => [0.540302, 0.841471, 0.000000, 0.000000, -0.841471, 0.540302, 0.000000, 0.000000, 0.000000, 0.000000, 1.000000, 0.000000, 0.000000, 0.000000, 0.000000, 1.000000]},
+     {:angle => 3.2, :expected => [-0.998295, -0.058374, 0.000000, 0.000000, 0.058374, -0.998295, 0.000000, 0.000000, 0.000000, 0.000000, 1.000000, 0.000000, 0.000000, 0.000000, 0.000000, 1.000000]}].each do |data|
+      matrix = Geo3d::Matrix.rotation_z data[:angle]
+      data[:expected].size.should == 16
+      expected = Geo3d::Matrix.new *data[:expected]
+      matrix.should == expected
+    end
+  end
+
+  it "should have an arbitrary axis rotation constructor" do
+    [{:axis => [1, 1, 0], :angle => 88.7, :expected => [0.870782, 0.129218, -0.474385, 0.000000, 0.129218, 0.870782, 0.474385, 0.000000, 0.474385, -0.474385, 0.741564, 0.000000, 0.000000, 0.000000, 0.000000, 1.000000]}].each do |data|
+      matrix = Geo3d::Matrix.rotation Geo3d::Vector.new(*data[:axis]), data[:angle]
+      data[:expected].size.should == 16
+      expected = Geo3d::Matrix.new *data[:expected]
+      matrix.should == expected
+    end
+  end
+
+  it "should have a reflection constructor" do
+    [{:plane => [0, 1, 0, 0], :expected => [1.000000, 0.000000, 0.000000, 0.000000, 0.000000, -1.000000, 0.000000, 0.000000, 0.000000, 0.000000, 1.000000, 0.000000, 0.000000, 0.000000, 0.000000, 1.000000]},
+     {:plane => [0, 1, 0, 1], :expected => [1.000000, 0.000000, 0.000000, 0.000000, 0.000000, -1.000000, 0.000000, 0.000000, 0.000000, 0.000000, 1.000000, 0.000000, 0.000000, -2.000000, 0.000000, 1.000000]}].each do |data|
+      matrix = Geo3d::Matrix.reflection Geo3d::Plane.new(*data[:plane])
+      data[:expected].size.should == 16
+      expected = Geo3d::Matrix.new *data[:expected]
+      matrix.should == expected
+    end
+  end
+
+  it "should have a shadow constructor" do
+    [{:plane => [0, 1, 0, 1], :light_pos => [0, 700, 0, 1], :expected => [701.000000, 0.000000, 0.000000, 0.000000, 0.000000, 1.000000, 0.000000, -1.000000, 0.000000, 0.000000, 701.000000, 0.000000, 0.000000, -700.000000, 0.000000, 700.000000]}].each do |data|
+      matrix = Geo3d::Matrix.shadow Geo3d::Vector.new(*data[:light_pos]), Geo3d::Plane.new(*data[:plane])
+      data[:expected].size.should == 16
+      expected = Geo3d::Matrix.new *data[:expected]
+      matrix.should == expected
+    end
+  end
+
+  it "multiplying a matrix by the identity matrix should result in the same matrix" do
+    identity = Geo3d::Matrix.identity
+    10.times do
+      r = random_matrix
+      (r * identity).should == r
+      (identity * r).should == r
+    end
+  end
+
+  it "should transform vectors" do
+
+  end
+
+  it "should multiply with other matrices" do
+
+  end
+end

data/spec/lib/plane_spec.rb

@@ -0,0 +1,80 @@
+require 'spec_helper'
+
+describe Geo3d::Plane do
+  it "should default all values to zero" do
+    p = Geo3d::Plane.new
+    p.a.zero?.should == true
+    p.b.zero?.should == true
+    p.c.zero?.should == true
+    p.d.zero?.should == true
+  end
+
+  it "should construct from a point and a normal" do
+    [{:point => [0, 0, 0], :normal => [0, 1, 0], :expected => [0, 1, 0, 0]},
+     {:point => [1, 2, 3], :normal => [1, 1, 1], :expected => [1, 1, 1, -6]},
+     {:point => [221, 772, 33], :normal => [2, 0, 1], :expected => [2, 0, 1, -475]},
+     {:point => [999, 888, 777], :normal => [-1, 3, 0], :expected => [-1, 3, 0, -1665]}].each do |data|
+      plane = Geo3d::Plane.from_point_and_normal Geo3d::Vector.new(*data[:point]), Geo3d::Vector.new(*data[:normal])
+      expected = Geo3d::Plane.new *data[:expected]
+      plane.should == expected
+    end
+  end
+
+  it "should construct from points" do
+    [{:a => [1, 1, 1], :b => [2, 2, 2], :c => [3, 3, 3], :expected => [0, 0, 0, 0]},
+     {:a => [-1.5, 1.5, 3.0, 0], :b => [1.5, 1.5, 3.0, 0], :c => [-1.5, -1.5, 3.0, 0], :expected => [0, 0, -1, 3]},
+     {:a => [10, 1, 33], :b => [1, 11, 3], :c => [-1, -1, 3], :expected => [-0.930808, 0.155135, 0.330954, -1.768534]}].each do |data|
+      plane = Geo3d::Plane.from_points Geo3d::Vector.new(*data[:a]), Geo3d::Vector.new(*data[:b]), Geo3d::Vector.new(*data[:c])
+      expected = Geo3d::Plane.new *data[:expected]
+      plane.should == expected
+    end
+  end
+
+  it "should support dot products with vectors" do
+    [{:plane => [1, 1, 1, 1], :vector => [2, 2, 2, 2], :expected => 8},
+     {:plane => [0, 1, 0, -99], :vector => [0, -42, 2, 52], :expected => -5190},
+     {:plane => [91, -2731, 1, 123], :vector => [2, 7, -9, 2], :expected => -18698},
+    ].each do |data|
+      plane = Geo3d::Plane.new *data[:plane]
+      vector = Geo3d::Vector.new *data[:vector]
+      Geo3d::Utils.float_cmp(plane.dot(vector), data[:expected]).should == true
+    end
+  end
+
+  it "should be normalizable" do
+    [{:plane => [0, 0, -1, 3], :expected => [0, 0, -1, 3]},
+     {:plane => [11, 11, -7, 3], :expected => [0.644831, 0.644831, -0.410347, 0.175863]},
+     {:plane => [-56, 23, 923, 9], :expected => [-0.060542, 0.024865, 0.997856, 0.009730]}].each do |data|
+      plane = Geo3d::Plane.new(*data[:plane]).normalize
+      expected = Geo3d::Plane.new *data[:expected]
+      plane.should == expected
+    end
+  end
+
+  it "should be able to detect line intersections" do
+    [{:plane => [0,0,-1,3], :line_start => [1,1,1,0], :line_end => [2,2,2,0], :expected => [3,3,3,0]},
+     {:plane => [0,0,-1,3], :line_start => [1,1,1,1], :line_end => [2,2,2,1], :expected => [3,3,3,1]},
+     {:plane => [0,1,0,-30], :line_start => [1,0,0,0], :line_end => [2,0,0,0], :expected => nil},
+     {:plane => [0,1,0,-30], :line_start => [1,1,0,0], :line_end => [2,0,0,0], :expected => [-28,30,0,0]},
+     {:plane => [0,1,0,-30], :line_start => [1,1,0,1], :line_end => [2,0,0,1], :expected => [-28,30,0,1]}].each do |data|
+      plane = Geo3d::Plane.new *data[:plane]
+      line_start = Geo3d::Vector.new *data[:line_start]
+      line_end = Geo3d::Vector.new *data[:line_end]
+      if data[:expected]
+        expected = Geo3d::Vector.new *data[:expected]
+      else
+        expected = nil
+      end
+      plane.line_intersection(line_start, line_end).should == expected
+    end
+  end
+
+  it "should be transformable" do
+    test_transform = ->(matrix, plane,expected) do
+      plane.transform(matrix).should == expected
+    end
+    test_transform.call Geo3d::Matrix.translation(0,5,0), Geo3d::Plane.new(0,1,0,0), Geo3d::Plane.new(0,1,0,-5)
+    test_transform.call Geo3d::Matrix.translation(0,5,0), Geo3d::Plane.new(1,1,1,1), Geo3d::Plane.new(1,1,1,-4)
+    test_transform.call Geo3d::Matrix.rotation_x(1), Geo3d::Plane.new(1,1,1,1), Geo3d::Plane.new(1.000000, -0.301169, 1.381773, 1.000000)
+  end
+end

data/spec/lib/quaternion_spec.rb

@@ -0,0 +1,113 @@
+require 'spec_helper'
+
+describe Geo3d::Quaternion do
+  it "should default all values to zero" do
+    q = Geo3d::Quaternion.new
+    q.x.zero?.should == true
+    q.y.zero?.should == true
+    q.z.zero?.should == true
+    q.w.zero?.should == true
+  end
+
+  it "should be constructable from an axis and angle" do
+    [{:axis => [0, 1, 0], :angle => 1, :expected => [0.000000, 0.479426, 0.000000, 0.877583]},
+     {:axis => [0, -1, 0], :angle => 1, :expected => [0.000000, -0.479426, 0.000000, 0.877583]},
+     {:axis => [0, 1, 0], :angle => -1, :expected => [0.000000, -0.479426, 0.000000, 0.877583]},
+     {:axis => [0, 1, 0], :angle => -6, :expected => [-0.000000, -0.141120, -0.000000, -0.989992]},
+     {:axis => [-213, 133, 22, -232], :angle => -3432, :expected => [0.538065, -0.335975, -0.055575, 0.771050]}].each do |data|
+      Geo3d::Quaternion.from_axis(Geo3d::Vector.new(*data[:axis]), data[:angle]).should == Geo3d::Quaternion.new(*data[:expected])
+    end
+  end
+
+  it "should be constructable from a rotation matrix" do
+    Geo3d::Quaternion.from_matrix(Geo3d::Matrix.rotation_x 1).should == Geo3d::Quaternion.new(0.479426, 0.000000, -0.000000, 0.877583)
+    Geo3d::Quaternion.from_matrix(Geo3d::Matrix.rotation_y 1).should == Geo3d::Quaternion.new(-0.000000, 0.479426, -0.000000, 0.877583)
+    Geo3d::Quaternion.from_matrix(Geo3d::Matrix.rotation_z 1).should == Geo3d::Quaternion.new(-0.000000, 0.000000, 0.479426, 0.877583)
+    Geo3d::Quaternion.from_matrix(Geo3d::Matrix.rotation_x 3.2).should == Geo3d::Quaternion.new(0.999574, 0.000000, 0.000000, -0.029200)
+  end
+
+  it "should be able to construct as the identity quaternion" do
+    q = Geo3d::Quaternion.identity
+    q.should == Geo3d::Quaternion.new(0, 0, 0, 1)
+    q.identity?.should == true
+  end
+
+  it "should be able to convert to a rotation matrix" do
+
+  end
+
+  it "should return axis of rotation" do
+    for i in 0..10000
+      angle = 0.1 * i + 0.1
+     # puts "angle is #{angle}"
+      #Geo3d::Quaternion.from_matrix(Geo3d::Matrix.rotation_x angle).axis.should == Geo3d::Vector.new(1, 0, 0)
+      #Geo3d::Quaternion.from_matrix(Geo3d::Matrix.rotation_y angle).axis.should == Geo3d::Vector.new(0, 1, 0)
+      #Geo3d::Quaternion.from_matrix(Geo3d::Matrix.rotation_z angle).axis.should == Geo3d::Vector.new(0, 0, 1)
+    end
+  end
+
+  it "should return rotation amount as angle" do
+
+  end
+
+  it "should return conjugate" do
+    [{:quaternion => [1, 1, 1, 1], :expected => [-1, -1, -1, 1]}].each do |data|
+      quaternion = Geo3d::Quaternion.new *data[:quaternion]
+      expected = Geo3d::Quaternion.new *data[:expected]
+      quaternion.conjugate.should == expected
+    end
+  end
+
+  it "should return inverse" do
+    [{:quaternion => [1, 1, 1, 1], :expected => [-0.250000, -0.250000, -0.250000, 0.250000]},
+     {:quaternion => [-1, -1, -1, -1], :expected => [0.250000, 0.250000, 0.250000, -0.250000]}].each do |data|
+      quaternion = Geo3d::Quaternion.new *data[:quaternion]
+      expected = Geo3d::Quaternion.new *data[:expected]
+      quaternion.inverse.should == expected
+    end
+  end
+
+  it "should support dot products with other quaternions" do
+    [{:a => [1, 1, 1, 1], :b => [2, 2, 2, 2], :expected => 8},
+     {:a => [0, 1, 0, -99], :b => [0, -42, 2, 52], :expected => -5190},
+     {:a => [91, -2731, 1, 123], :b => [2, 7, -9, 2], :expected => -18698},
+    ].each do |data|
+      a = Geo3d::Quaternion.new *data[:a]
+      b = Geo3d::Quaternion.new *data[:b]
+      Geo3d::Utils.float_cmp(a.dot(b), data[:expected]).should == true
+    end
+  end
+
+  it "should return length" do
+    [{:quaternion => [0, 0, -1, 3], :expected => 3.162278},
+     {:quaternion => [11, 11, -7, 3], :expected => 17.320509},
+     {:quaternion => [-56, 23, 923, 9], :expected => 925.027039}].each do |data|
+      quaternion = Geo3d::Quaternion.new *data[:quaternion]
+      expected = data[:expected]
+      Geo3d::Utils.float_cmp(quaternion.length, expected).should == true
+    end
+  end
+
+  it "should return length squared" do
+    [{:quaternion => [0, 0, -1, 3], :expected => 10},
+     {:quaternion => [11, 11, -7, 3], :expected => 300},
+     {:quaternion => [-56, 23, 923, 9], :expected => 855675}].each do |data|
+      quaternion = Geo3d::Quaternion.new *data[:quaternion]
+      expected = data[:expected]
+      Geo3d::Utils.float_cmp(quaternion.length_squared, expected).should == true
+    end
+  end
+
+  it "should be normalizable" do
+    [{:quaternion => [0, 0, -1, 3], :expected => [0, 0, -0.316228, 0.948683]},
+     {:quaternion => [11, 11, -7, 3], :expected => [0.635085, 0.635085, -0.404145, 0.173205]},
+     {:quaternion => [-56, 23, 923, 9], :expected => [-0.060539, 0.024864, 0.997809, 0.009729]}].each do |data|
+      quaternion = Geo3d::Quaternion.new(*data[:quaternion]).normalize
+      expected = Geo3d::Quaternion.new *data[:expected]
+      quaternion.should == expected
+    end
+  end
+
+  #todo: add tests for quaternion interpolation
+
+end

data/spec/lib/vector_spec.rb

@@ -0,0 +1,77 @@
+require 'spec_helper'
+
+describe Geo3d::Vector do
+  it "should default all values to zero" do
+    v = Geo3d::Vector.new
+    v.x.zero?.should == true
+    v.y.zero?.should == true
+    v.z.zero?.should == true
+    v.w.zero?.should == true
+  end
+
+  it "should support dot products with other vectors" do
+    [{:a => [1, 1, 1, 1], :b => [2, 2, 2, 2], :expected => 8},
+     {:a => [0, 1, 0, -99], :b => [0, -42, 2, 52], :expected => -5190},
+     {:a => [91, -2731, 1, 123], :b => [2, 7, -9, 2], :expected => -18698},
+    ].each do |data|
+      a = Geo3d::Vector.new *data[:a]
+      b = Geo3d::Vector.new *data[:b]
+      Geo3d::Utils.float_cmp(a.dot(b), data[:expected]).should == true
+    end
+  end
+
+  it "should support cross products with other vectors" do
+    [{:a => [1,0,0,0], :b => [0,1,0,0], :expected => [0,0,1,0] },
+     {:a => [1,0,0,1], :b => [0,1,0,1], :expected => [0,0,1,0] },
+     {:a => [1,1,1,1], :b => [1,1,1,1], :expected => [0,0,0,0] },
+     {:a => [2,99,6,0], :b => [-11,-91,77,0], :expected => [8169.000000, -220.000000, 907.000000, 0.000000] }].each do |data|
+      a = Geo3d::Vector.new *data[:a]
+      b = Geo3d::Vector.new *data[:b]
+      expected = Geo3d::Vector.new *data[:expected]
+      a.cross(b).should == expected
+      b.cross(a).should == -expected
+    end
+  end
+
+  it "should return length" do
+    [{:vector => [0, 0, -1, 3], :expected => 3.162278},
+     {:vector => [11, 11, -7, 3], :expected => 17.320509},
+     {:vector => [-56, 23, 923, 9], :expected => 925.027039}].each do |data|
+      vector = Geo3d::Vector.new *data[:vector]
+      expected = data[:expected]
+      Geo3d::Utils.float_cmp(vector.length, expected).should == true
+    end
+  end
+
+  it "should return length squared" do
+    [{:vector => [0, 0, -1, 3], :expected => 10},
+     {:vector => [11, 11, -7, 3], :expected => 300},
+     {:vector => [-56, 23, 923, 9], :expected => 855675}].each do |data|
+      vector = Geo3d::Vector.new *data[:vector]
+      expected = data[:expected]
+      Geo3d::Utils.float_cmp(vector.length_squared, expected).should == true
+    end
+  end
+
+  it "should be normalizable" do
+    [{:vector => [0, 0, -1, 3], :expected => [0, 0, -0.316228, 0.948683]},
+     {:vector => [11, 11, -7, 3], :expected => [0.635085, 0.635085, -0.404145, 0.173205]},
+     {:vector => [-56, 23, 923, 9], :expected => [-0.060539, 0.024864, 0.997809, 0.009729]}].each do |data|
+      vector = Geo3d::Vector.new(*data[:vector]).normalize
+      expected = Geo3d::Vector.new *data[:expected]
+      vector.should == expected
+    end
+  end
+
+  it "should be able to linearly interpolate" do
+    [{:a => [0,0,0,0], :b => [1,1,1,1], :interpolate_fraction => 0.5, :expected => [0.5, 0.5, 0.5, 0.5]},
+     {:a => [23,-3,425,-332], :b => [-22,-45443,886,122], :interpolate_fraction => 0.21234433, :expected => [13.444505, -9651.926758, 522.890747, -235.595673]}].each do |data|
+      a = Geo3d::Vector.new *data[:a]
+      b = Geo3d::Vector.new *data[:b]
+      expected = Geo3d::Vector.new *data[:expected]
+      s = data[:interpolate_fraction]
+      a.lerp( b, s).should == expected
+    end
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1 @@
+require 'geo3d'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: geo3d
 version: !ruby/object:Gem::Version
-  version: 0.0.5
+  version: 0.0.6
 platform: ruby
 authors:
 - Misha Conway
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-01-13 00:00:00.000000000 Z
+date: 2014-01-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -38,6 +38,20 @@ dependencies:
     - - '>='
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Library for common 3d graphics vector and matrix operations
 email:
 - MishaAConway@gmail.com
@@ -54,9 +68,15 @@ files:
 - lib/geo3d.rb
 - lib/geo3d/version.rb
 - lib/matrix.rb
+- lib/plane.rb
 - lib/quaternion.rb
 - lib/utils.rb
 - lib/vector.rb
+- spec/lib/matrix_spec.rb
+- spec/lib/plane_spec.rb
+- spec/lib/quaternion_spec.rb
+- spec/lib/vector_spec.rb
+- spec/spec_helper.rb
 homepage: https://github.com/MishaConway/geo3d
 licenses:
 - MIT
@@ -81,4 +101,9 @@ rubygems_version: 2.1.11
 signing_key: 
 specification_version: 4
 summary: Library for common 3d graphics vector and matrix operations
-test_files: []
+test_files:
+- spec/lib/matrix_spec.rb
+- spec/lib/plane_spec.rb
+- spec/lib/quaternion_spec.rb
+- spec/lib/vector_spec.rb
+- spec/spec_helper.rb