gmath3D 0.2.1 → 0.2.2

data/lib/vector3.rb

@@ -37,6 +37,15 @@ public
     # [Output]
     #  return true if rhs equals myself.
     def ==(rhs)
+      return false if( !rhs.kind_of?(Vector3) )
+      equals_inner(rhs)
+    end
+
+    # For using Vector3 as hash key
+    def hash
+      [@x.to_f, @y.to_f, @z.to_f].hash
+    end
+    def eql?(rhs)
       equals_inner(rhs)
     end
 
@@ -169,7 +178,6 @@ public
 
     private
     def equals_inner(rhs)
-      return false if( !rhs.kind_of?(Vector3) )
       return false if((self.x - rhs.x).abs > @tolerance) 
       return false if((self.y - rhs.y).abs > @tolerance) 
       return false if((self.z - rhs.z).abs > @tolerance) 

data/test/test_finite_line.rb

@@ -25,6 +25,13 @@ class FiniteLineTestCase < MiniTest::Unit::TestCase
   end
 
   def test_equals
+    line = FiniteLine.new()
+    shallow_copied = line
+    assert(line == shallow_copied)
+    assert(line.equal?(shallow_copied))
+    assert(line != nil)
+    assert(line != "string")
+
     assert_equal(FiniteLine.new(Vector3.new(1,2,3), Vector3.new(2,3,4)),
                 FiniteLine.new(Vector3.new(1.0,2.0,3.0), Vector3.new(2.0,3.0,4.0)))
 
@@ -33,6 +40,23 @@ class FiniteLineTestCase < MiniTest::Unit::TestCase
     assert(FiniteLine.new(Vector3.new(1,2,3), Vector3.new(2,3,4)) != FiniteLine.new(Vector3.new(2,3,4), Vector3.new(1,2,3)))
   end
 
+  def test_clone
+    line = FiniteLine.new()
+    shallow_copied = line
+    shallow_copied.start_point.x = -1
+    assert(line == shallow_copied)
+    assert(line.equal?(shallow_copied))
+    assert_equal(-1, shallow_copied.start_point.x)
+
+    cloned = line.clone
+    assert(line == cloned)
+    assert(!line.equal?(cloned))
+    cloned.start_point.x = -2
+    assert_equal(-2, cloned.start_point.x)
+
+    assert_equal(-1, line.start_point.x) # original never changed in editing cloned one.
+  end
+
   def test_direction
     start_point_tmp = Vector3.new(1.0,  0.0, 2.0)
     end_point_tmp   = Vector3.new(1.0, -3.5, 1.0)

data/test/test_line.rb

@@ -19,6 +19,39 @@ class LineTestCase < MiniTest::Unit::TestCase
     assert(Vector3.new(1,0,0) == lineDefault.direction )
   end
 
+  def test_equals
+    line = Line.new()
+    shallow_copied = line
+    assert(line.equal?(shallow_copied))
+    assert(line == shallow_copied)
+    assert(line != nil)
+    assert(line != "string")
+
+    assert_equal(Line.new(Vector3.new(1,2,3), Vector3.new(2,3,4)), Line.new(Vector3.new(1.0,2.0,3.0), Vector3.new(2.0,3.0,4.0)))
+
+    assert(Line.new(Vector3.new(1,2,3), Vector3.new(2,3,4)) == Line.new(Vector3.new(1.0,2.0,3.0), Vector3.new(2.0,3.0,4.0)))
+    assert(Line.new(Vector3.new(1,2,3), Vector3.new(2,3,3)) != Line.new(Vector3.new(1.0,2.0,3.0), Vector3.new(2.0,3.0,4.0)))
+    assert(Line.new(Vector3.new(1,2,3), Vector3.new(2,3,4)) != Line.new(Vector3.new(2,3,4), Vector3.new(1,2,3)))
+  end
+
+  def test_clone
+    line = Line.new()
+    shallow_copied = line
+    shallow_copied.base_point.x = -1
+    assert(line == shallow_copied)
+    assert(line.equal?(shallow_copied))
+    assert_equal(-1, shallow_copied.base_point.x)
+    assert_equal(-1, line.base_point.x)
+
+    cloned = line.clone
+    assert(line == cloned)
+    assert(!line.equal?(cloned))
+    cloned.base_point.x = -2
+    assert_equal(-2, cloned.base_point.x)
+
+    assert_equal(-1, line.base_point.x) # original never changed in editing cloned one.
+  end
+
   def test_to_s
     line =  Line.new(Vector3.new(2.0, 3, 5), Vector3.new(1.0, 1.0, 1.0))
     assert_equal("Line[point[2.0, 3, 5], vector[1.0, 1.0, 1.0]", line.to_s);

data/test/test_plane.rb

@@ -25,6 +25,39 @@ class PlaneTestCase < MiniTest::Unit::TestCase
     assert_equal("Plane[point[0, 0, 1], normal[0.0, 0.0, 1.0]]", @plane.to_s)
   end
 
+  def test_equals
+    plane = Plane.new()
+    shallow_copied = plane
+    assert(plane.equal?(shallow_copied))
+    assert(plane == shallow_copied)
+    assert(plane != nil)
+    assert(plane != "string")
+
+    assert_equal(Plane.new(Vector3.new(1,2,3), Vector3.new(2,3,4)), Plane.new(Vector3.new(1.0,2.0,3.0), Vector3.new(2.0,3.0,4.0)))
+
+    assert(Plane.new(Vector3.new(1,2,3), Vector3.new(2,3,4)) == Plane.new(Vector3.new(1.0,2.0,3.0), Vector3.new(2.0,3.0,4.0)))
+    assert(Plane.new(Vector3.new(1,2,3), Vector3.new(2,3,4)) == Plane.new(Vector3.new(1.0,2.0,3.0), Vector3.new(4.0,6,8.0)))
+    assert(Plane.new(Vector3.new(1,2,3), Vector3.new(2,3,3)) != Plane.new(Vector3.new(1.0,2.0,3.0), Vector3.new(2.0,3.0,4.0)))
+    assert(Plane.new(Vector3.new(1,2,3), Vector3.new(2,3,4)) != Plane.new(Vector3.new(2,3,4), Vector3.new(1,2,3)))
+  end
+
+  def test_clone
+    plane = Plane.new()
+    shallow_copied = plane
+    shallow_copied.base_point.x = -1
+    assert(plane == shallow_copied)
+    assert(plane.equal?(shallow_copied))
+    assert_equal(-1, shallow_copied.base_point.x)
+
+    cloned = plane.clone
+    assert(plane == cloned)
+    assert(!plane.equal?(cloned))
+    cloned.base_point.x = -2
+    assert_equal(-2, cloned.base_point.x)
+
+    assert_equal(-1, plane.base_point.x) # original never changed in editing cloned one.
+  end
+
   def test_distance_to_point
     target_point = Vector3.new(1,2,3)
     distance, closest_point = @plane.distance(target_point)

data/test/test_polyline.rb

@@ -0,0 +1,86 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'helper'
+
+include GMath3D
+
+MiniTest::Unit.autorun
+
+class PolylineTestCase < MiniTest::Unit::TestCase
+  def setup
+    @vertices = Array.new(6)
+    @vertices[0] = Vector3.new(1,0,0)
+    @vertices[1] = Vector3.new(2.0,0,0)
+    @vertices[2] = Vector3.new(3,1,0)
+    @vertices[3] = Vector3.new(2,2,1)
+    @vertices[4] = Vector3.new(1,2,0)
+    @vertices[5] = Vector3.new(0,1,0)
+    @polyline_open = Polyline.new(@vertices, true)
+    @polyline_closed = Polyline.new(@vertices, false)
+  end
+
+  def test_initialize
+    idx = 0
+    @vertices.each do |vertex|
+      assert_equal(@polyline_open.vertices[idx], vertex)
+      assert_equal(@polyline_closed.vertices[idx], vertex)
+      idx += 1
+    end
+    assert_equal( true,  @polyline_open.is_open )
+    assert_equal( false, @polyline_closed.is_open )
+  end
+
+  def test_equals
+    shallow_copied = @polyline_open
+    assert(@polyline_open.equal?(shallow_copied))
+    assert(@polyline_open == shallow_copied)
+    assert(@polyline_open != nil)
+    assert(@polyline_open != "string")
+
+    assert(@polyline_open != @polyline_closed)
+
+    polyline_new_open = Polyline.new(@vertices, true)
+    assert(!@polyline_open.equal?(polyline_new_open))
+    assert(@polyline_open == polyline_new_open)
+    assert_equal(@polyline_open, polyline_new_open)
+
+    new_vertices = @vertices.clone
+    new_vertices.push( Vector3.new(3,4,5))
+    polyline_new_open = Polyline.new(new_vertices, true)
+    assert(polyline_new_open != @polyline_open)
+    assert(@polyline_open != polyline_new_open)
+  end
+
+  def test_clone
+    shallow_copied = @polyline_open
+    vert_cnt = @polyline_open.vertices.size
+    shallow_copied.vertices[vert_cnt - 1].x = 20
+    assert(@polyline_open == shallow_copied)
+    assert(@polyline_open.equal?(shallow_copied))
+    assert_equal(20, @polyline_open.vertices[vert_cnt - 1].x)
+    assert_equal(20, shallow_copied.vertices[vert_cnt - 1].x)
+
+    cloned = @polyline_open.clone
+    assert(@polyline_open == cloned)
+    assert(!@polyline_open.equal?(cloned))
+
+    cloned.vertices[vert_cnt - 1].x = -20
+    assert_equal(-20, cloned.vertices[vert_cnt - 1].x)
+    assert_equal(20, @polyline_open.vertices[vert_cnt - 1].x) # original never changed in editing cloned one.
+
+    cloned.is_open = false
+    assert_equal(false, cloned.is_open)
+    assert_equal(true,  @polyline_open.is_open)
+  end
+
+  def test_to_s
+    assert_equal("Polyline[[1, 0, 0], [2.0, 0, 0], [3, 1, 0], [2, 2, 1], [1, 2, 0], [0, 1, 0]] open",
+           @polyline_open.to_s);
+    assert_equal("Polyline[[1, 0, 0], [2.0, 0, 0], [3, 1, 0], [2, 2, 1], [1, 2, 0], [0, 1, 0]] closed",
+           @polyline_closed.to_s);
+  end
+
+  def test_center
+    assert_equal(Vector3.new(1.5, 1.0, 1.0/6.0), @polyline_open.center)
+    assert_equal(Vector3.new(1.5, 1.0, 1.0/6.0), @polyline_closed.center)
+  end
+end

data/test/test_quat.rb

@@ -132,4 +132,13 @@ class QuatTestCase < MiniTest::Unit::TestCase
     end
   end
 
+  def test_normalize
+    quat = Quat.new(-1,2,1,1)
+    quat = quat.normalize()
+    assert_equal(-1/Math.sqrt(6), quat.x)
+    assert_equal( 2/Math.sqrt(6), quat.y)
+    assert_equal( 1/Math.sqrt(6), quat.z)
+    assert_equal( 1/Math.sqrt(6), quat.w)
+  end
+
 end

data/test/test_rectangle.rb

@@ -21,6 +21,42 @@ class RectangleTestCase < MiniTest::Unit::TestCase
     assert_equal(Vector3.new(0,1,0), @rectangle_default.v_vector)
   end
 
+  def test_equals
+    assert(@rectangle != nil)
+    assert(@rectangle != "string")
+
+    shallow_copied = @rectangle
+    assert(@rectangle.equal?(shallow_copied))
+    assert(@rectangle == shallow_copied)
+
+    assert_equal(@rectangle, Rectangle.new( Vector3.new(1,2,3), Vector3.new(0,-0.5,0), Vector3.new(0,0,2)))
+    assert(@rectangle == Rectangle.new( Vector3.new(1,2,3), Vector3.new(0,-0.5,0), Vector3.new(0,0,2.0)))
+    assert(@rectangle != Rectangle.new( Vector3.new(1,2,3), Vector3.new(0,-0.5,0), Vector3.new(0,0,2.2)))
+  end
+
+  def test_clone
+    shallow_copied = @rectangle
+    shallow_copied.base_point.x = -1
+    assert(@rectangle == shallow_copied)
+    assert(@rectangle.equal?(shallow_copied))
+    assert_equal(-1, shallow_copied.base_point.x)
+    assert_equal(-1, @rectangle.base_point.x)
+
+    cloned = @rectangle.clone
+    assert(@rectangle == cloned)
+    assert(!@rectangle.equal?(cloned))
+    cloned.base_point.x = -2
+    cloned.u_vector.x = 4
+    cloned.v_vector.z = 6
+    assert_equal(-2, cloned.base_point.x)
+    assert_equal(4, cloned.u_vector.x)
+    assert_equal(6, cloned.v_vector.z)
+
+    assert_equal(-1, @rectangle.base_point.x) # original never changed in editing cloned one.
+    assert_equal(0,  @rectangle.u_vector.x)
+    assert_equal(2,  @rectangle.v_vector.z)
+  end
+
   def test_to_s
     assert_equal("Rectangle[base[1, 2, 3], u[0, -0.5, 0], v[0, 0, 2]", @rectangle.to_s)
   end
@@ -52,6 +88,15 @@ class RectangleTestCase < MiniTest::Unit::TestCase
     assert_equal(Vector3.new(1,2  ,3), edges[3].end_point)
   end
 
+  def test_vertices
+    vertices = @rectangle.vertices
+    assert_equal(4, vertices.size)
+    assert_equal(Vector3.new(1,2,3), vertices[0])
+    assert_equal(Vector3.new(1,1.5,3), vertices[1])
+    assert_equal(Vector3.new(1,1.5,5), vertices[2])
+    assert_equal(Vector3.new(1,2,5), vertices[3])
+  end
+
   def test_normal
     assert_equal(Vector3.new(-1,0,0), @rectangle.normal)
     assert_equal(Vector3.new(0,0,1), @rectangle_default.normal)

data/test/test_tri_mesh.rb

@@ -0,0 +1,167 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'helper'
+
+include GMath3D
+
+MiniTest::Unit.autorun
+
+class TriMeshTestCase < MiniTest::Unit::TestCase
+  def get_box_mesh
+    box = Box.new(Vector3.new(-1,-1,-1), Vector3.new(2,3,4))
+    return TriMesh.from_box(box)
+  end
+
+  def get_plane_mesh
+    rect = Rectangle.new(Vector3.new(-1,-1,-1), Vector3.new(2,0,0), Vector3.new(0,4,0) )
+    return TriMesh.from_rectangle(rect)
+  end
+
+  def test_initalize
+    plane_mesh = get_plane_mesh()
+    assert_equal( 2, plane_mesh.tri_indices.size)
+    assert_equal( 4, plane_mesh.vertices.size)
+
+    box_mesh = get_box_mesh()
+    assert_equal( 12, box_mesh.tri_indices.size)
+    assert_equal( 8, box_mesh.vertices.size)
+
+    assert_raises ArgumentError do
+      invalidResult = TriMesh.new(nil)
+    end
+    assert_raises ArgumentError do
+      invalidResult = TriMesh.new(Vector3.new(), 4.0)
+    end
+  end
+
+  def test_equal
+    plane_mesh = get_plane_mesh()
+    assert( plane_mesh != nil )
+    assert( plane_mesh != "String" )
+
+    shallow = plane_mesh
+    assert( shallow == plane_mesh )
+    assert( shallow.equal?(plane_mesh) )
+
+    new_mesh = get_plane_mesh()
+    assert( shallow == new_mesh )
+    assert( !shallow.equal?(new_mesh) )
+  end
+
+  def test_clone
+    plane_mesh = get_plane_mesh()
+    shallow = plane_mesh
+
+    shallow.vertices[0].x = 12
+    shallow.vertices[2] = Vector3.new(-3,2,5)
+    shallow.tri_indices[0] = [3,2,1]
+    shallow.tri_indices[1][2] = 2
+
+    assert_equal( 12, shallow.vertices[0].x )
+    assert_equal( 12, plane_mesh.vertices[0].x )
+    assert_equal( Vector3.new(-3,2,5), shallow.vertices[2] )
+    assert_equal( Vector3.new(-3,2,5), plane_mesh.vertices[2] )
+    assert_equal( [3,2,1], shallow.tri_indices[0] )
+    assert_equal( [3,2,1], plane_mesh.tri_indices[0] )
+    assert_equal( 2, shallow.tri_indices[1][2] )
+    assert_equal( 2, plane_mesh.tri_indices[1][2] )
+
+    deep = plane_mesh.clone
+    assert( deep == plane_mesh )
+    assert( !deep.equal?(plane_mesh) )
+
+    deep.vertices[0].x = -1
+    deep.vertices[2] = Vector3.new(4,2,1)
+    deep.tri_indices[0] = [4,2,2]
+    deep.tri_indices[1][2] = 5
+
+    assert_equal( -1, deep.vertices[0].x )
+    assert_equal( 12, plane_mesh.vertices[0].x )
+    assert_equal( Vector3.new(4,2,1), deep.vertices[2] )
+    assert_equal( Vector3.new(-3,2,5), plane_mesh.vertices[2] )
+    assert_equal( [4,2,2], deep.tri_indices[0] )
+    assert_equal( [3,2,1], plane_mesh.tri_indices[0] )
+    assert_equal( 5, deep.tri_indices[1][2] )
+    assert_equal( 2, plane_mesh.tri_indices[1][2] )
+  end
+
+  def test_to_s
+    assert_equal( "TriMesh[triangle_count:12, vertex_count:8]", get_box_mesh().to_s)
+  end
+
+  def test_triangles
+    vertices = [Vector3.new(0,0,0),Vector3.new(2,0,0),Vector3.new(2,2,0),Vector3.new(0,2,0)]
+    tri_indices = [[0,1,3],[1,2,3]]
+    tri_mesh = TriMesh.new(vertices, tri_indices)
+    triangles = tri_mesh.triangles
+    assert_equal(2, triangles.size)
+    assert_equal(Vector3.new(0,0,0), triangles[0].vertices[0])
+    assert_equal(Vector3.new(2,0,0), triangles[0].vertices[1])
+    assert_equal(Vector3.new(0,2,0), triangles[0].vertices[2])
+    assert_equal(Vector3.new(2,0,0), triangles[1].vertices[0])
+    assert_equal(Vector3.new(2,2,0), triangles[1].vertices[1])
+    assert_equal(Vector3.new(0,2,0), triangles[1].vertices[2])
+
+    triangle = tri_mesh.triangle(1)
+    assert_equal(Vector3.new(2,0,0), triangle.vertices[0])
+    assert_equal(Vector3.new(2,2,0), triangle.vertices[1])
+    assert_equal(Vector3.new(0,2,0), triangle.vertices[2])
+
+    triangle = tri_mesh.triangle(3)
+    assert_equal(nil, triangle)
+  end
+
+  def test_from_triangles
+    tris = Array.new(8)
+    tris[0] = Triangle.new( Vector3.new(0,0,0), Vector3.new(1,0,0), Vector3.new(0,1,1) )
+    tris[1] = Triangle.new( Vector3.new(1,0,0), Vector3.new(1,1,1), Vector3.new(0,1,1) )
+    tris[2] = Triangle.new( Vector3.new(1,0,0), Vector3.new(2,0,0), Vector3.new(1,1,1) )
+    tris[3] = Triangle.new( Vector3.new(2,0,0), Vector3.new(2,1,1), Vector3.new(1,1,1) )
+    tris[4] = Triangle.new( Vector3.new(0,1,1), Vector3.new(1,1,1), Vector3.new(0,2,2) )
+    tris[5] = Triangle.new( Vector3.new(1,1,1), Vector3.new(1,2,2), Vector3.new(0,2,2) )
+    tris[6] = Triangle.new( Vector3.new(1,1,1), Vector3.new(2,1,1), Vector3.new(1,2,2) )
+    tris[7] = Triangle.new( Vector3.new(2,1,1), Vector3.new(2,2,2), Vector3.new(1,2,2) )
+    trimesh_from_tris = TriMesh::from_triangles(tris)
+    assert_equal( 9, trimesh_from_tris.vertices.size)
+    assert_equal( 8, trimesh_from_tris.tri_indices.size)
+  end
+
+  def test_from_convex_polyline
+    vertices = Array.new(6)
+    vertices[0] = Vector3.new(1,0,0)
+    vertices[1] = Vector3.new(2,0,0)
+    vertices[2] = Vector3.new(3,1,0)
+    vertices[3] = Vector3.new(2,2,0)
+    vertices[4] = Vector3.new(1,2,0)
+    vertices[5] = Vector3.new(0,1,0)
+    polyline_closed = Polyline.new( vertices, false ) # closed Polyline
+    polyline_open   = Polyline.new( vertices, true  ) # open Polyline
+    trimesh_from_convex_polyline1 = TriMesh.from_convex_polyline( polyline_closed )
+    trimesh_from_convex_polyline2 = TriMesh.from_convex_polyline( polyline_open )
+
+    assert_equal(4, trimesh_from_convex_polyline1.area)
+    assert_equal(4, trimesh_from_convex_polyline2.area)
+  end
+
+  def test_from_extruded_polyline
+    vertices = Array.new(6)
+    vertices[0] = Vector3.new(1,0,0)
+    vertices[1] = Vector3.new(2,0,0)
+    vertices[2] = Vector3.new(3,1,0)
+    vertices[3] = Vector3.new(2,2,0)
+    vertices[4] = Vector3.new(1,2,0)
+    vertices[5] = Vector3.new(0,1,0)
+    polyline_closed = Polyline.new( vertices, false ) # closed Polyline
+    polyline_open   = Polyline.new( vertices, true  ) # open Polyline
+    extrude_direction = Vector3.new(0,0,2)
+    trimesh_from_extruded_polyline1 = TriMesh.from_extrude_polyline( polyline_closed , extrude_direction )
+    trimesh_from_extruded_polyline2 = TriMesh.from_extrude_polyline( polyline_open   , extrude_direction )
+
+    assert_in_delta(4+8*(Math.sqrt(2)), trimesh_from_extruded_polyline1.area, 1e-10)
+    assert_in_delta(4+6*(Math.sqrt(2)), trimesh_from_extruded_polyline2.area, 1e-10)
+  end
+
+  def test_area
+    box_mesh = get_box_mesh()
+    assert_equal(94, box_mesh.area)
+  end
+end

data/test/test_triangle.rb

@@ -21,6 +21,36 @@ class TriangleTestCase < MiniTest::Unit::TestCase
     assert_equal(Vector3.new(0,1,0), @triangle_default.vertices[2])
   end
 
+  def test_equals
+    assert(@triangle != nil)
+    assert(@triangle != "string")
+
+    shallow_copied = @triangle
+    assert(@triangle.equal?(shallow_copied))
+    assert(@triangle == shallow_copied)
+
+    assert_equal(@triangle, Triangle.new( Vector3.new(1.0,2.0,2.0), Vector3.new(1.0,4.0,2.0), Vector3.new(-1.0,3.0,0.0)))
+    assert(@triangle == Triangle.new( Vector3.new(1.0,2.0,2.0), Vector3.new(1.0,4.0,2.0), Vector3.new(-1.0,3.0,0.0)))
+    assert(@triangle != Triangle.new( Vector3.new(1.0,2.0,2.0), Vector3.new(1.0,4.0,2.0), Vector3.new(-1.0,3.0,0.5)))
+  end
+
+  def test_clone
+    shallow_copied = @triangle
+    shallow_copied.vertices[2].x = 1
+    assert(@triangle == shallow_copied)
+    assert(@triangle.equal?(shallow_copied))
+    assert_equal(1, @triangle.vertices[2].x)
+    assert_equal(1, shallow_copied.vertices[2].x)
+
+    cloned =@triangle.clone
+    assert(@triangle == cloned)
+    assert(!@triangle.equal?(cloned))
+
+    cloned.vertices[2].x = -10
+    assert_equal(-10, cloned.vertices[2].x)
+    assert_equal(1, @triangle.vertices[2].x) # original never changed in editing cloned one.
+  end
+
   def test_to_s
     assert_equal("Triangle[[1, 2, 2], [1, 4, 2], [-1, 3, 0]]", @triangle.to_s)
   end
@@ -60,6 +90,13 @@ class TriangleTestCase < MiniTest::Unit::TestCase
     assert_equal( Vector3.new(0,0,1) ,@triangle_default.normal )
   end
 
+  def test_reverse
+    current_normal = @triangle.normal()
+    reversed_normal = @triangle.reverse().normal()
+    assert( current_normal.parallel?(reversed_normal) )
+    assert( !current_normal.same_direction?(reversed_normal) )
+  end
+
   def test_center
     center = @triangle.center
     assert_in_delta( 0.333333333333333, center.x, @triangle.tolerance)

data/test/test_vector3.rb

@@ -54,14 +54,57 @@ class Vector3TestCase < MiniTest::Unit::TestCase
     @vector.x = "this is a pen"
   end
 
+  def test_clone
+    vec1 = Vector3.new(1,2,3)
+    vec1_shallow_copy = vec1
+    vec1_shallow_copy.x = 4
+    assert_equal( 4, vec1.x )
+    assert_equal( 2, vec1.y )
+    assert_equal( 3, vec1.z )
+
+    vec1_deep_copy = vec1.clone
+    vec1_deep_copy.x = 6
+    assert_equal( 4, vec1.x )
+    assert_equal( 6, vec1_deep_copy.x )
+
+    vec_ary = [Vector3.new(1,2,3), Vector3.new(4,5,6)]
+    vec_ary_shallow = vec_ary
+    vec_ary_shallow[0].x = 4
+    vec_ary_shallow[1] = Vector3.new(7,8,9)
+    vec_ary_shallow.push(Vector3.new(10,11,12))
+    assert_equal(4, vec_ary_shallow[0].x)
+    assert_equal(Vector3.new(7,8,9), vec_ary_shallow[1])
+    assert_equal(3, vec_ary_shallow.size)
+    assert_equal(4, vec_ary[0].x)
+    assert_equal(Vector3.new(7,8,9), vec_ary[1])
+    assert_equal(3, vec_ary.size)
+
+    vec_ary = [Vector3.new(1,2,3), Vector3.new(4,5,6)]
+    vec_ary_deep = vec_ary.clone
+    vec_ary_deep[0].x = 4
+    vec_ary_deep[1] = Vector3.new(7,8,9)
+    vec_ary_deep.push(Vector3.new(10,11,12))
+    assert_equal(4, vec_ary_deep[0].x)
+    assert_equal(Vector3.new(7,8,9), vec_ary_deep[1])
+    assert_equal(3, vec_ary_deep.size)
+
+    # Array.clone does not call element.clone
+#    assert_equal(1, vec_ary[0].x)
+    assert_equal(4, vec_ary[0].x)
+    assert_equal(Vector3.new(4,5,6), vec_ary[1])
+    assert_equal(2, vec_ary.size)
+  end
+
   def test_equals
     assert(!(@vector_init_zero == @vector))
     assert(@vector_init_zero != @vector)
 
     assert(@vector == @vector)
+    assert(@vector.eql?(@vector))
 
     vector = Vector3.new(1,2,3)
     assert(@vector == vector)
+    assert(@vector.eql?(vector))
 
     # Floating error check
     floatingError = Geom.default_tolerance*0.1
@@ -79,6 +122,28 @@ class Vector3TestCase < MiniTest::Unit::TestCase
     assert(@vector != -4)
   end
 
+  def test_equ_hash
+    # in case use Vector3 as Key of hash...
+    # Vector3#eql? and Vector3#hash should be implement
+    hash = Hash.new()
+    vec = Vector3.new(1,2,3)
+    hash[vec] = 1
+    assert_equal(1, hash.keys.count)
+    assert_equal(1, hash[vec])
+
+    hash[vec] = 2
+    assert_equal(1, hash.keys.count)
+    assert_equal(2, hash[vec])
+
+    hash[Vector3.new(3,2,1)] = 3
+    assert_equal(2, hash.keys.count)
+    assert_equal(2, hash[vec])
+
+    hash[@vector] = 3
+    assert_equal(2, hash.keys.count)
+    assert_equal(3, hash[vec])
+  end
+
   def test_add
     vector = Vector3.new(4,5,6)
     addedVector = vector + @vector

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: gmath3D
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.2.2
   prerelease: 
 platform: ruby
 authors:
@@ -9,12 +9,12 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-10-19 00:00:00.000000000 +09:00
+date: 2011-10-25 00:00:00.000000000 +09:00
 default_executable: 
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
-  requirement: &2156099140 !ruby/object:Gem::Requirement
+  requirement: &2152196520 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -22,10 +22,10 @@ dependencies:
         version: 1.0.0
   type: :development
   prerelease: false
-  version_requirements: *2156099140
+  version_requirements: *2152196520
 - !ruby/object:Gem::Dependency
   name: jeweler
-  requirement: &2156097640 !ruby/object:Gem::Requirement
+  requirement: &2152195120 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -33,7 +33,7 @@ dependencies:
         version: 1.6.4
   type: :development
   prerelease: false
-  version_requirements: *2156097640
+  version_requirements: *2152195120
 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
@@ -58,8 +58,10 @@ files:
 - lib/line.rb
 - lib/matrix_util.rb
 - lib/plane.rb
+- lib/polyline.rb
 - lib/quat.rb
 - lib/rectangle.rb
+- lib/tri_mesh.rb
 - lib/triangle.rb
 - lib/util.rb
 - lib/vector3.rb
@@ -70,8 +72,10 @@ files:
 - test/test_line.rb
 - test/test_matrix_util.rb
 - test/test_plane.rb
+- test/test_polyline.rb
 - test/test_quat.rb
 - test/test_rectangle.rb
+- test/test_tri_mesh.rb
 - test/test_triangle.rb
 - test/test_util.rb
 - test/test_vector3.rb
@@ -91,7 +95,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 3561879194129992333
+      hash: -2118171931574002143
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements: