gmath3D 0.1.1

data/test/test_triangle.rb

@@ -0,0 +1,143 @@
+include GMath3D
+
+MiniTest::Unit.autorun
+
+class TriangleTestCase < MiniTest::Unit::TestCase
+  def setup
+    @triangle = Triangle.new( Vector3.new(1,2,2), Vector3.new(1,4,2), Vector3.new(-1,3,0))
+    @triangle_default = Triangle.new()
+  end
+
+  def test_initialize
+    assert_equal(Vector3.new(1,2,2), @triangle.vertices[0])
+    assert_equal(Vector3.new(1,4,2), @triangle.vertices[1])
+    assert_equal(Vector3.new(-1,3,0), @triangle.vertices[2])
+
+    assert_equal(Vector3.new(0,0,0), @triangle_default.vertices[0])
+    assert_equal(Vector3.new(1,0,0), @triangle_default.vertices[1])
+    assert_equal(Vector3.new(0,1,0), @triangle_default.vertices[2])
+  end
+
+  def test_point
+    assert_equal(@triangle.vertices[0], @triangle.point( Array.new([1,0,0])))
+    assert_equal(@triangle.vertices[1], @triangle.point( Array.new([0,1,0])))
+    assert_equal(@triangle.vertices[2], @triangle.point( Array.new([0,0,1])))
+
+    #on edge
+    assert_equal(Vector3.new(1,3,2), @triangle.point( Array.new([0.5,0.5,0])))
+    assert_equal(Vector3.new(0,3.5,1), @triangle.point( Array.new([0,0.5,0.5])))
+    assert_equal(Vector3.new(0,2.5,1), @triangle.point( Array.new([0.5,0,0.5])))
+
+    #inside
+    assert_equal(Vector3.new(0, 3, 1), @triangle.point( Array.new([0.25,0.25,0.5])))
+    assert_equal(@triangle.center, @triangle.point( Array.new([1.0/3.0,1.0/3.0,1.0/3.0])))
+  end
+
+  def test_edges
+    edges = @triangle.edges
+    assert_equal(@triangle.vertices[0], edges[0].start_point)
+    assert_equal(@triangle.vertices[1], edges[0].end_point)
+    assert_equal(@triangle.vertices[1], edges[1].start_point)
+    assert_equal(@triangle.vertices[2], edges[1].end_point)
+    assert_equal(@triangle.vertices[2], edges[2].start_point)
+    assert_equal(@triangle.vertices[0], edges[2].end_point)
+  end
+
+  def test_area
+    assert_in_delta(Math::sqrt(8), @triangle.area, @triangle.tolerance)
+    assert_in_delta(0.5, @triangle_default.area, @triangle_default.tolerance)
+  end
+
+  def test_normal
+    assert_equal( Vector3.new(-1,0,1).normalize(), @triangle.normal )
+    assert_equal( Vector3.new(0,0,1) ,@triangle_default.normal )
+  end
+
+  def test_center
+    center = @triangle.center
+    assert_in_delta( 0.333333333333333, center.x, @triangle.tolerance)
+    assert_in_delta( 3.0, center.y, @triangle.tolerance)
+    assert_in_delta( 1.333333333333333, center.z, @triangle.tolerance)
+
+    barycentric_coordinate = @triangle.barycentric_coordinate(center)
+    assert_in_delta( 1.0/3.0, barycentric_coordinate[0], @triangle.tolerance)
+    assert_in_delta( 1.0/3.0, barycentric_coordinate[1], @triangle.tolerance)
+    assert_in_delta( 1.0/3.0, barycentric_coordinate[2], @triangle.tolerance)
+  end
+
+  def test_barycentric_coordinate
+    # on vertex
+    coord = @triangle.barycentric_coordinate( @triangle.vertices[1])
+    assert_equal( 3, coord.size )
+    assert_in_delta( 0, coord[0], @triangle.tolerance)
+    assert_in_delta( 1, coord[1], @triangle.tolerance)
+    assert_in_delta( 0, coord[2], @triangle.tolerance)
+
+    # on edge
+    coord = @triangle.barycentric_coordinate( Vector3.new(1,3,2) )
+    assert_in_delta( 0.5, coord[0], @triangle.tolerance)
+    assert_in_delta( 0.5, coord[1], @triangle.tolerance)
+    assert_in_delta( 0, coord[2], @triangle.tolerance)
+
+    # inside case
+    coord = @triangle.barycentric_coordinate( Vector3.new(0,3,1) )
+    assert_in_delta( 1.0, coord[0] + coord[1] + coord[2], @triangle.tolerance)
+    assert_in_delta( 0.25, coord[0], @triangle.tolerance)
+    assert_in_delta( 0.25, coord[1], @triangle.tolerance)
+    assert_in_delta( 0.5, coord[2], @triangle.tolerance)
+
+    # outside case
+    coord = @triangle_default.barycentric_coordinate( Vector3.new(2,0,0) )
+    assert_in_delta( -1.0, coord[0], @triangle.tolerance)
+    assert_in_delta( 2.0, coord[1], @triangle.tolerance)
+    assert_in_delta( 0.0, coord[2], @triangle.tolerance)
+
+    # outside case
+    coord = @triangle.barycentric_coordinate( Vector3.new(3,3,4) )
+    assert_in_delta(  1.0, coord[0], @triangle.tolerance)
+    assert_in_delta(  1.0, coord[1], @triangle.tolerance)
+    assert_in_delta( -1.0, coord[2], @triangle.tolerance)
+
+    #invalid argument
+    assert_raises ArgumentError do
+      coord = @triangle.barycentric_coordinate( 3 )
+    end
+    assert_raises ArgumentError do
+      coord = @triangle.barycentric_coordinate( nil )
+    end
+  end
+
+  def test_contains
+    check_point = @triangle.center + @triangle.normal*3.0
+    assert( !@triangle.contains( check_point) )
+    assert( @triangle.contains( @triangle.center) )
+    assert( @triangle.contains( Vector3.new( 1,3,2)))
+    assert( @triangle.contains( Vector3.new(-1,3,0)))
+    assert( @triangle_default.contains( Vector3.new( 0.5, 0.5, 0.0 ) ))
+    assert( !@triangle_default.contains( Vector3.new( -1.0, 2.0, 0.0 )))
+    assert( !@triangle_default.contains( Vector3.new( 1.0, 1.0, 0.0 )))
+  end
+
+  def test_distance_to_point
+    # on inside
+    check_point = @triangle.center + @triangle.normal*3.0
+    distance, point_on_triangle = @triangle.distance(check_point)
+    assert_in_delta(3.0, distance, @triangle.tolerance)
+    assert_equal(@triangle.center, point_on_triangle)
+
+    # on vertex
+    distance, point_on_triangle = @triangle_default.distance(Vector3.new(-1,-1,0.5))
+    assert_in_delta(Math::sqrt(2.25), distance, @triangle_default.tolerance)
+    assert_equal(@triangle_default.vertices[0], point_on_triangle)
+
+    # on edge
+    distance, point_on_triangle = @triangle.distance( Vector3.new(2,3,2))
+    assert_in_delta(1, distance, @triangle_default.tolerance)
+    assert_equal(Vector3.new(1,3,2), point_on_triangle)
+
+    # contains to inside
+    distance, point_on_triangle = @triangle_default.distance(@triangle_default.center)
+    assert_in_delta(0, distance, @triangle_default.tolerance)
+    assert_equal(@triangle_default.center, point_on_triangle)
+  end
+end

data/test/test_util.rb

@@ -0,0 +1,54 @@
+include GMath3D
+
+MiniTest::Unit.autorun
+
+class UtilTestCase < MiniTest::Unit::TestCase
+  def test_check_arg_type
+    integerInstance = 1
+    floatInstance = 3.1415
+    stringInstance = 'string'
+
+   # no exception raise
+    Util.check_arg_type(Integer, integerInstance)
+    Util.check_arg_type(Float, floatInstance)
+    Util.check_arg_type(String, stringInstance)
+
+    # exception raise
+    assert_raises ArgumentError do
+      Util.check_arg_type(Integer, floatInstance)
+    end
+    assert_raises ArgumentError do
+      Util.check_arg_type(Integer, stringInstance)
+    end
+    assert_raises ArgumentError do
+      Util.check_arg_type(Float, integerInstance)
+    end
+    assert_raises ArgumentError do
+      Util.check_arg_type(Float, stringInstance)
+    end
+    assert_raises ArgumentError do
+      Util.check_arg_type(String, integerInstance)
+    end
+    assert_raises ArgumentError do
+      Util.check_arg_type(String, floatInstance)
+    end
+  end
+
+  def test_array_methods
+    point_ary = Array.new([Vector3.new(2,4,3),Vector3.new(-2,2.5,8),Vector3.new(9,0,-3)])
+    assert_equal( Vector3.new(9, 6.5, 8), point_ary.sum)
+    assert_equal( Vector3.new(3, 6.5/3, 8/3.0), point_ary.avg)
+  end
+
+  def test_matrix_equation_solving
+    mat = Matrix[[1,2,3],[4,5,6],[7,8,-9]]
+    vec = Matrix.column_vector([26,62,8])
+    inv_mat = mat.inverse
+    ans = inv_mat*vec
+    assert_equal(3, ans.row_size)
+    assert_equal(1, ans.column_size)
+    assert_equal(3, ans[0,0])
+    assert_equal(4, ans[1,0])
+    assert_equal(5, ans[2,0])
+  end
+end

data/test/test_vector3.rb

@@ -0,0 +1,319 @@
+include GMath3D
+
+MiniTest::Unit.autorun
+
+class Vector3TestCase < MiniTest::Unit::TestCase
+  def setup
+    @vector_init_zero = Vector3.new()
+    @vector = Vector3.new(1.0, 2.0, 3.0)
+  end
+
+  def test_initalize
+    assert_equal(0, @vector_init_zero.x)
+    assert_equal(0, @vector_init_zero.y)
+    assert_equal(0, @vector_init_zero.z)
+
+    assert_equal(1.0, @vector.x)
+    assert_equal(2.0, @vector.y)
+    assert_equal(3.0, @vector.z)
+
+    assert_equal(Geom.default_tolerance, @vector.tolerance)
+  end
+
+  def test_assign_value
+    assert_equal(1.0, @vector.x)
+    assert_equal(2.0, @vector.y)
+    assert_equal(3.0, @vector.z)
+
+    @vector.x = 2.0
+    @vector.y *= 2.0
+    @vector.z -= 3.0
+
+    assert_equal(2.0, @vector.x)
+    assert_equal(4.0, @vector.y)
+    assert_equal(0.0, @vector.z)
+  end
+
+  def test_assign_invalid_value
+    #TODO unimplemented!
+    @vector.x = "this is a pen"
+  end
+
+  def test_equals
+    assert(!(@vector_init_zero == @vector))
+    assert(@vector_init_zero != @vector)
+
+    assert(@vector == @vector)
+
+    vector = Vector3.new(1,2,3)
+    assert(@vector == vector)
+
+    # Floating error check
+    floatingError = Geom.default_tolerance*0.1
+    vector = Vector3.new(1.0 - floatingError, 2.0 + floatingError, 3.0)
+    assert(@vector == vector)
+
+    floatingError2 = Geom.default_tolerance*10.0
+    vector = Vector3.new(1.0 - floatingError2, 2.0 + floatingError2, 3.0)
+    assert(@vector != vector)
+
+    #invlid value comparison
+    assert(@vector != "string")
+    assert(@vector != -4)
+  end
+
+  def test_add
+    vector = Vector3.new(4,5,6)
+    addedVector = vector + @vector
+
+    assert_equal(5.0, addedVector.x)
+    assert_equal(7.0, addedVector.y)
+    assert_equal(9.0, addedVector.z)
+
+    addedVector = @vector + vector
+
+    assert_equal(5.0, addedVector.x)
+    assert_equal(7.0, addedVector.y)
+    assert_equal(9.0, addedVector.z)
+  end
+  def test_add_invalid_value
+    assert_raises ArgumentError do
+      invalidResult = @vector + 5
+    end
+    assert_raises ArgumentError do
+      invalidResult = @vector + nil
+    end
+  end
+
+  def test_subtract
+    vector = Vector3.new(4,5,6)
+    subtractedVector = vector - @vector
+
+    assert_equal(3.0, subtractedVector.x)
+    assert_equal(3.0, subtractedVector.y)
+    assert_equal(3.0, subtractedVector.z)
+
+    subtractedVector = @vector - vector
+
+    assert_equal(-3.0, subtractedVector.x)
+    assert_equal(-3.0, subtractedVector.y)
+    assert_equal(-3.0, subtractedVector.z)
+  end
+  def test_subtract_invalid_value
+    assert_raises ArgumentError do
+      invalidResult = @vector - 5
+    end
+    assert_raises ArgumentError do
+      invalidResult = @vector - nil
+    end
+  end
+
+  def test_multiply
+    multipliedVector = @vector * 5
+
+    assert_equal( 5.0, multipliedVector.x)
+    assert_equal(10.0, multipliedVector.y)
+    assert_equal(15.0, multipliedVector.z)
+
+    multipliedVector = @vector * -3.0
+
+    assert_equal(-3.0, multipliedVector.x)
+    assert_equal(-6.0, multipliedVector.y)
+    assert_equal(-9.0, multipliedVector.z)
+  end
+  def test_multiply_invalid_value
+    assert_raises ArgumentError do
+      invalidResult = @vector * @vector
+    end
+    assert_raises ArgumentError do
+      invalidResult = @vector * nil
+    end
+  end
+
+  def test_divide
+    dividedVector = @vector / 5
+
+    assert_equal(1.0/5.0, dividedVector.x)
+    assert_equal(2.0/5.0, dividedVector.y)
+    assert_equal(3.0/5.0, dividedVector.z)
+
+    dividedVector = @vector / -3.0
+
+    assert_equal(-1.0/3.0, dividedVector.x)
+    assert_equal(-2.0/3.0, dividedVector.y)
+    assert_equal(-3.0/3.0, dividedVector.z)
+  end
+  def test_divide_invalid_value
+    assert_raises ArgumentError do
+      invalidResult = @vector / @vector
+    end
+    assert_raises ArgumentError do
+      invalidResult = @vector / nil
+    end
+  end
+
+  def test_dot
+    vector = Vector3.new(2.0, 4.0, 6.0)
+    innerProduct = @vector.dot(vector)
+    assert_in_delta( 1.0*2.0 + 2.0*4.0 + 3.0*6.0, innerProduct, @vector.tolerance)
+
+    innerProduct = @vector.dot(@vector_init_zero)
+    assert_in_delta( 0.0, innerProduct, @vector.tolerance)
+  end
+  def test_dot_invalid_value
+    assert_raises ArgumentError do
+      invalidResult = @vector.dot(5.0)
+    end
+    assert_raises ArgumentError do
+      invalidResult = @vector.dot(nil)
+    end
+  end
+
+  def test_cross
+    outerProduct = Vector3.new(1.0,0.0,0.0).cross(Vector3.new(0.0,1.0,0.0))
+    assert(outerProduct == Vector3.new(0.0,0.0,1.0))
+
+    vector = Vector3.new(1.0, 1.0, 4.0)
+    outerProduct = @vector.cross(vector)
+    assert_in_delta(2.0*4.0 - 3.0*1.0, outerProduct.x, @vector.tolerance)
+    assert_in_delta(3.0*1.0 - 1.0*4.0, outerProduct.y, @vector.tolerance)
+    assert_in_delta(1.0*1.0 - 2.0*1.0, outerProduct.z, @vector.tolerance)
+
+    outerProduct = @vector.cross(@vector_init_zero)
+    assert_in_delta( 0.0, outerProduct.x, @vector.tolerance)
+    assert_in_delta( 0.0, outerProduct.y, @vector.tolerance)
+    assert_in_delta( 0.0, outerProduct.z, @vector.tolerance)
+  end
+  def test_cross_invalid_value
+    assert_raises ArgumentError do
+      invalidResult = @vector.cross(5.0)
+    end
+    assert_raises ArgumentError do
+      invalidResult = @vector.cross(nil)
+    end
+  end
+
+  def test_length
+    assert_in_delta(0.0, @vector_init_zero.length, @vector_init_zero.tolerance)
+    assert_in_delta( Math::sqrt(1.0*1.0+2.0*2.0+3.0*3.0), @vector.length, @vector.tolerance)
+    vector = Vector3.new(3.0, 4.0, 0.0)
+    assert_in_delta( 5.0, vector.length, @vector.tolerance)
+  end
+
+  def test_distance
+    point1 = Vector3.new(1.0,  3.0, -5.0)
+    point2 = Vector3.new(3.0, -5.5,  2.2)
+    vector1to2 = point2 - point1
+    assert_in_delta( vector1to2.length, point2.distance(point1), vector1to2.tolerance)
+    assert_in_delta( vector1to2.length, point1.distance(point2), vector1to2.tolerance)
+    assert_in_delta( 0.0, point1.distance(point1), vector1to2.tolerance)
+  end
+  def test_distance_invalid_value
+    assert_raises ArgumentError do
+      invalidResult = @vector.distance(5.0)
+    end
+    assert_raises ArgumentError do
+      invalidResult = @vector.distance(nil)
+    end
+  end
+
+  def test_angle
+    vector1 = Vector3.new(  1.0 ,  0.0, 0.0 )
+    vector2 = Vector3.new(  1.0 ,  1.0, 0.0 )
+    vector3 = Vector3.new( -1.0 ,  1.0, 0.0 )
+    vector4 = Vector3.new( -1.0 ,  0.0, 0.0 )
+    vector5 = Vector3.new( -1.0 , -1.0, 0.0 )
+    vector6 = Vector3.new(  1.0 , -1.0, 0.0 )
+
+    # result should be between 0 and PI.
+    assert_in_delta(0.0,vector1.angle(vector1), vector1.tolerance) ;
+    assert_in_delta(Math::PI/4.0,vector1.angle(vector2), vector1.tolerance) ;
+    assert_in_delta(Math::PI*3.0/4.0, vector1.angle(vector3), vector1.tolerance) ;
+    assert_in_delta(Math::PI, vector1.angle(vector4), vector1.tolerance) ;
+    assert_in_delta(Math::PI*3.0/4.0, vector1.angle(vector5), vector1.tolerance) ;
+    assert_in_delta(Math::PI/4.0, vector1.angle(vector6), vector1.tolerance) ;
+  end
+  def test_angle_invalid_value
+    assert_raises ArgumentError do
+      invalidResult = @vector.angle(5.0)
+    end
+    assert_raises ArgumentError do
+      invalidResult = @vector.angle(nil)
+    end
+  end
+
+  def test_normalize
+    normalized = @vector.normalize()
+    assert_in_delta(1.0, normalized.length, normalized.tolerance) ;
+    assert(normalized.same_direction?(@vector))
+  end
+
+  def test_parallel
+    vectorZero = Vector3.new( 0.0, 0.0, 0.0) ;
+    vector1 = Vector3.new( 1.0, 2.0, 3.0 ) ;
+    vector2 = Vector3.new( 1.0, 1.0, 4.0 ) ;
+    vector3 = Vector3.new( 2.0, 4.0, 6.0 ) ;
+    vector4 = Vector3.new( -1.0, -2.0, -3.0 ) ;
+    vector5 = Vector3.new( -3.0, -6.0, -9.0 ) ;
+
+    assert(!vector1.parallel?(vectorZero)) ;
+    assert(!vectorZero.parallel?(vector2)) ;
+    assert(!vector1.parallel?(vector2)) ;
+
+    assert(vector1.parallel?(vector3)) ;
+    assert(vector1.parallel?(vector4)) ;
+    assert(vector1.parallel?(vector5)) ;
+  end
+
+  def test_same_direction
+    vectorZero = Vector3.new( 0.0, 0.0, 0.0) ;
+    vector1 = Vector3.new( 1.0, 2.0, 3.0 ) ;
+    vector2 = Vector3.new( 1.0, 1.0, 4.0 ) ;
+    vector3 = Vector3.new( 2.0, 4.0, 6.0 ) ;
+    vector4 = Vector3.new( -1.0, -2.0, -3.0 ) ;
+    vector5 = Vector3.new( -3.0, -6.0, -9.0 ) ;
+
+    assert(!vector1.same_direction?(vectorZero)) ;
+    assert(!vectorZero.same_direction?(vector2)) ;
+    assert(!vector1.same_direction?(vector2)) ;
+
+    assert(vector1.same_direction?(vector3)) ;
+    assert(!vector1.same_direction?(vector4)) ;
+    assert(!vector1.same_direction?(vector5)) ;
+  end
+
+  def test_project
+    vector1 = Vector3.new(1.0, 1.0, 0.0)
+    vector2 = Vector3.new(0.0, 1.0, 0.0)
+
+    projectedVector, parameter = vector2.project_to(vector1)
+    assert(Vector3.new(0.5,0.5,0.0) == projectedVector)
+    assert_in_delta(0.5, parameter, projectedVector.tolerance)
+
+    projectedVector, parameter = vector2.project_to(Vector3.new(0.0, 0.0, 0.0))
+    assert(Vector3.new() == projectedVector)
+    assert_in_delta(0.0, parameter, projectedVector.tolerance)
+
+    vector3 = Vector3.new(5.0, -1.0, 4.0)
+    projectedVector, parmeter = vector3.project_to(vector1)
+    assert(projectedVector.same_direction?(vector1))
+  end
+
+  def test_to_column_vector
+    matrix = @vector.to_column_vector
+    assert_equal( 3, matrix.row_size )
+    assert_equal( 1, matrix.column_size )
+    assert_equal( 1, matrix[0,0])
+    assert_equal( 2, matrix[1,0])
+    assert_equal( 3, matrix[2,0])
+
+    matrix = @vector_init_zero.to_column_vector
+    assert_equal( 3, matrix.row_size )
+    assert_equal( 1, matrix.column_size )
+    assert_equal( 0, matrix[0,0])
+    assert_equal( 0, matrix[1,0])
+    assert_equal( 0, matrix[2,0])
+  end
+
+
+end

metadata

@@ -0,0 +1,104 @@
+--- !ruby/object:Gem::Specification
+name: gmath3D
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+  prerelease: 
+platform: ruby
+authors:
+- Toshiyasu Shimizu
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-09-24 00:00:00.000000000 +09:00
+default_executable: 
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: &2164436460 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+  type: :development
+  prerelease: false
+  version_requirements: *2164436460
+- !ruby/object:Gem::Dependency
+  name: jeweler
+  requirement: &2164435040 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.6.4
+  type: :development
+  prerelease: false
+  version_requirements: *2164435040
+description: This library defines 3D geometric elements(point, line, plane etc..).
+  It can get two(or more) elements relation, like distance between two elements.
+email: toshi0328@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- LICENSE.txt
+- README.rdoc
+files:
+- .document
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.rdoc
+- Rakefile
+- VERSION
+- gmath3D.gemspec
+- lib/box.rb
+- lib/finite_line.rb
+- lib/geom.rb
+- lib/gmath3D.rb
+- lib/line.rb
+- lib/plane.rb
+- lib/rectangle.rb
+- lib/triangle.rb
+- lib/util.rb
+- lib/vector3.rb
+- test/helper.rb
+- test/test_box.rb
+- test/test_finite_line.rb
+- test/test_geom.rb
+- test/test_gmath3D.rb
+- test/test_line.rb
+- test/test_plane.rb
+- test/test_rectangle.rb
+- test/test_triangle.rb
+- test/test_util.rb
+- test/test_vector3.rb
+has_rdoc: true
+homepage: http://github.com/toshi0328/gmath3D
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: -1522515577061844315
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.6.2
+signing_key: 
+specification_version: 3
+summary: Geometric elements in 3D
+test_files: []