gmath3D 0.2.5 → 1.0.0

data/test/test_geom.rb

@@ -1,17 +1,17 @@
-$LOAD_PATH.unshift(File.dirname(__FILE__))
-require 'helper'
-
-include GMath3D
-
-MiniTest::Unit.autorun
-
-class GeomTestCase < MiniTest::Unit::TestCase
-  def test_tolerance
-    default_tolerance = Geom.default_tolerance
-    geomObject = Geom.new
-    assert_equal(default_tolerance, geomObject.tolerance)
-    geomObject.tolerance = 1e-8
-    assert_equal(1e-8, geomObject.tolerance)
-    assert_equal(default_tolerance, Geom.default_tolerance)
-  end
-end
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'helper'
+
+include GMath3D
+
+MiniTest::Unit.autorun
+
+class GeomTestCase < MiniTest::Unit::TestCase
+  def test_tolerance
+    default_tolerance = Geom.default_tolerance
+    geomObject = Geom.new
+    assert_equal(default_tolerance, geomObject.tolerance)
+    geomObject.tolerance = 1e-8
+    assert_equal(1e-8, geomObject.tolerance)
+    assert_equal(default_tolerance, Geom.default_tolerance)
+  end
+end

data/test/test_line.rb

@@ -1,146 +1,146 @@
-$LOAD_PATH.unshift(File.dirname(__FILE__))
-require 'helper'
-
-include GMath3D
-
-MiniTest::Unit.autorun
-
-class LineTestCase < MiniTest::Unit::TestCase
-  def test_initialize
-    base_point_tmp = Vector3.new(2.0, 3.0, 5.0)
-    direction_tmp  = Vector3.new(1.0, 1.0, 1.0)
-    line = Line.new(base_point_tmp, direction_tmp)
-
-    assert(base_point_tmp == line.base_point)
-    assert(direction_tmp  == line.direction )
-
-    lineDefault = Line.new()
-    assert(Vector3.new(0,0,0) == lineDefault.base_point)
-    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);
-  end
-
-  def test_point
-    base_point_tmp = Vector3.new(2.0, 3.0, 5.0)
-    direction_tmp  = Vector3.new(1.0, 1.0, 0.0)
-    line = Line.new(base_point_tmp, direction_tmp)
-
-    assert(Vector3.new(2.0, 3.0, 5.0) == line.point(0.0))
-    assert(Vector3.new(3.0, 4.0, 5.0) == line.point(1.0))
-    assert(Vector3.new(2.5, 3.5, 5.0) == line.point(0.5))
-    assert(Vector3.new(4.0, 5.0, 5.0) == line.point(2))
-    assert(Vector3.new(1.0, 2.0, 5.0) == line.point(-1.0))
-  end
-
-  def test_distance_to_point
-    base_point_tmp = Vector3.new(2.0, 3.0, 5.0)
-    direction_tmp  = Vector3.new(1.0, 1.0, 0.0)
-    line = Line.new(base_point_tmp, direction_tmp)
-
-    check_point1 = base_point_tmp + Vector3.new(-1.0, 1.0, 0.0)
-    distance, closest_point, parameter = line.distance(check_point1)
-    assert_in_delta(Math::sqrt(2.0), distance, line.tolerance)
-    assert(base_point_tmp == closest_point)
-    assert_in_delta(0.0, parameter, line.tolerance)
-
-    check_point2 = check_point1 + direction_tmp
-    distance, closest_point, parameter = line.distance(check_point2)
-    assert_in_delta(Math::sqrt(2.0), distance, line.tolerance)
-    assert(base_point_tmp + direction_tmp == closest_point)
-    assert_in_delta(1.0, parameter, line.tolerance)
-
-    check_point3 = line.point(0.3)
-    distance, closest_point = line.distance(check_point3)
-    assert_in_delta(0.0, distance, line.tolerance)
-    assert(check_point3 == closest_point)
-
-    target_point4 = Vector3.new(2,3,3)
-    line2 = Line.new( Vector3.new(1,2,3), Vector3.new(0,2,0))
-    distance, point_on_line, parameter = line2.distance( target_point4 )
-    assert_in_delta( 1, distance, line.tolerance )
-    assert_equal( Vector3.new(1,3,3), point_on_line )
-    assert_in_delta( 0.5, parameter, line.tolerance ) 
-  end
-
-  def test_distance_to_line
-    base_point_tmp1 = Vector3.new(0.0, 0.0, 0.0)
-    direction_tmp1  = Vector3.new(1.0, 1.0, 0.0)
-    line1 = Line.new(base_point_tmp1, direction_tmp1)
-
-    base_point_tmp2 = Vector3.new(1.0, 1.0, 3.0)
-    direction_tmp2  = Vector3.new(-1.0, 1.0, 0.0)
-    line2 = Line.new(base_point_tmp2, direction_tmp2)
-
-    distance, point1, point2, parameter1, parameter2 = line1.distance(line2)
-    assert_in_delta(3.0, distance, line1.tolerance)
-    assert(Vector3.new(1.0, 1.0, 0.0) == point1)
-    assert(Vector3.new(1.0, 1.0, 3.0) == point2)
-    assert_in_delta(1.0, parameter1, line1.tolerance)
-    assert_in_delta(0.0, parameter2, line2.tolerance)
-
-    # distance for same lines
-    distance, point1, point2, parameter1, parameter2 = line1.distance(line1)
-    assert_in_delta(0.0, distance, line1.tolerance)
-    assert_equal(nil, point1)
-    assert_equal(nil, point2)
-    assert_equal(nil, parameter1)
-    assert_equal(nil, parameter2)
-
-    # parallel case
-    base_point_tmp3 = Vector3.new(0.0, 0.0, 4.0)
-    direction_tmp3  = Vector3.new(-1.0, -1.0, 0.0)
-    line3 = Line.new(base_point_tmp3, direction_tmp3)
-    distance, point1, point2, parameter1, parameter2 = line1.distance(line3)
-    assert_in_delta(4.0, distance, line3.tolerance)
-    assert_equal(nil, point1)
-    assert_equal(nil, point2)
-    assert_equal(nil, parameter1)
-    assert_equal(nil, parameter2)
-  end
-
-  def test_distance_to_invalid_value
-    assert_raises ArgumentError do
-      invalidResult = Line.new.distance(nil)
-    end
-    assert_raises ArgumentError do
-      invalidResult = Line.new.distance(5.0)
-    end
-  end
-end
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'helper'
+
+include GMath3D
+
+MiniTest::Unit.autorun
+
+class LineTestCase < MiniTest::Unit::TestCase
+  def test_initialize
+    base_point_tmp = Vector3.new(2.0, 3.0, 5.0)
+    direction_tmp  = Vector3.new(1.0, 1.0, 1.0)
+    line = Line.new(base_point_tmp, direction_tmp)
+
+    assert(base_point_tmp == line.base_point)
+    assert(direction_tmp  == line.direction )
+
+    lineDefault = Line.new()
+    assert(Vector3.new(0,0,0) == lineDefault.base_point)
+    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);
+  end
+
+  def test_point
+    base_point_tmp = Vector3.new(2.0, 3.0, 5.0)
+    direction_tmp  = Vector3.new(1.0, 1.0, 0.0)
+    line = Line.new(base_point_tmp, direction_tmp)
+
+    assert(Vector3.new(2.0, 3.0, 5.0) == line.point(0.0))
+    assert(Vector3.new(3.0, 4.0, 5.0) == line.point(1.0))
+    assert(Vector3.new(2.5, 3.5, 5.0) == line.point(0.5))
+    assert(Vector3.new(4.0, 5.0, 5.0) == line.point(2))
+    assert(Vector3.new(1.0, 2.0, 5.0) == line.point(-1.0))
+  end
+
+  def test_distance_to_point
+    base_point_tmp = Vector3.new(2.0, 3.0, 5.0)
+    direction_tmp  = Vector3.new(1.0, 1.0, 0.0)
+    line = Line.new(base_point_tmp, direction_tmp)
+
+    check_point1 = base_point_tmp + Vector3.new(-1.0, 1.0, 0.0)
+    distance, closest_point, parameter = line.distance(check_point1)
+    assert_in_delta(Math::sqrt(2.0), distance, line.tolerance)
+    assert(base_point_tmp == closest_point)
+    assert_in_delta(0.0, parameter, line.tolerance)
+
+    check_point2 = check_point1 + direction_tmp
+    distance, closest_point, parameter = line.distance(check_point2)
+    assert_in_delta(Math::sqrt(2.0), distance, line.tolerance)
+    assert(base_point_tmp + direction_tmp == closest_point)
+    assert_in_delta(1.0, parameter, line.tolerance)
+
+    check_point3 = line.point(0.3)
+    distance, closest_point = line.distance(check_point3)
+    assert_in_delta(0.0, distance, line.tolerance)
+    assert(check_point3 == closest_point)
+
+    target_point4 = Vector3.new(2,3,3)
+    line2 = Line.new( Vector3.new(1,2,3), Vector3.new(0,2,0))
+    distance, point_on_line, parameter = line2.distance( target_point4 )
+    assert_in_delta( 1, distance, line.tolerance )
+    assert_equal( Vector3.new(1,3,3), point_on_line )
+    assert_in_delta( 0.5, parameter, line.tolerance ) 
+  end
+
+  def test_distance_to_line
+    base_point_tmp1 = Vector3.new(0.0, 0.0, 0.0)
+    direction_tmp1  = Vector3.new(1.0, 1.0, 0.0)
+    line1 = Line.new(base_point_tmp1, direction_tmp1)
+
+    base_point_tmp2 = Vector3.new(1.0, 1.0, 3.0)
+    direction_tmp2  = Vector3.new(-1.0, 1.0, 0.0)
+    line2 = Line.new(base_point_tmp2, direction_tmp2)
+
+    distance, point1, point2, parameter1, parameter2 = line1.distance(line2)
+    assert_in_delta(3.0, distance, line1.tolerance)
+    assert(Vector3.new(1.0, 1.0, 0.0) == point1)
+    assert(Vector3.new(1.0, 1.0, 3.0) == point2)
+    assert_in_delta(1.0, parameter1, line1.tolerance)
+    assert_in_delta(0.0, parameter2, line2.tolerance)
+
+    # distance for same lines
+    distance, point1, point2, parameter1, parameter2 = line1.distance(line1)
+    assert_in_delta(0.0, distance, line1.tolerance)
+    assert_equal(nil, point1)
+    assert_equal(nil, point2)
+    assert_equal(nil, parameter1)
+    assert_equal(nil, parameter2)
+
+    # parallel case
+    base_point_tmp3 = Vector3.new(0.0, 0.0, 4.0)
+    direction_tmp3  = Vector3.new(-1.0, -1.0, 0.0)
+    line3 = Line.new(base_point_tmp3, direction_tmp3)
+    distance, point1, point2, parameter1, parameter2 = line1.distance(line3)
+    assert_in_delta(4.0, distance, line3.tolerance)
+    assert_equal(nil, point1)
+    assert_equal(nil, point2)
+    assert_equal(nil, parameter1)
+    assert_equal(nil, parameter2)
+  end
+
+  def test_distance_to_invalid_value
+    assert_raises ArgumentError do
+      invalidResult = Line.new.distance(nil)
+    end
+    assert_raises ArgumentError do
+      invalidResult = Line.new.distance(5.0)
+    end
+  end
+end

data/test/test_matrix_util.rb

@@ -1,84 +1,84 @@
-# -*- coding: cp932 -*-
-$LOAD_PATH.unshift(File.dirname(__FILE__))
-require 'helper'
-
-include GMath3D
-
-MiniTest::Unit.autorun
-
-class MatrixTestCase < MiniTest::Unit::TestCase
-  def setup
-    @mat_default = Matrix.zero(3)
-    @mat = Matrix[[1,2,3],[4,5,6],[7,8,9]]
-  end
-
-  def test_initalize
-    @mat_default.each do |cell|
-      assert_equal(0, cell)
-    end
-
-    i = 1
-    @mat.each do |cell|
-      assert_equal(i, cell)
-      i+=1
-    end
-  end
-
-  def test_to_s
-    assert_equal("Matrix[[0, 0, 0], [0, 0, 0], [0, 0, 0]]", @mat_default.to_s)
-    assert_equal("Matrix[[1, 2, 3], [4, 5, 6], [7, 8, 9]]", @mat.to_s)
-  end
-
-  def test_multiply
-    mat = Matrix[[3,2,1],[-4,2,1],[3,4,1]]
-    vec = Matrix.column_vector([2,3,4])
-    ans = mat*vec
-
-    assert_equal(ans[0,0], 16)
-    assert_equal(ans[1,0], 2 )
-    assert_equal(ans[2,0], 22)
-
-    vec2 = Vector3.new(2,3,4)
-    ans2 = mat*(vec2)
-    assert_equal(Vector3.new(16,2,22), ans2)
-  end
-
-  def test_from_axis
-    local_point = Vector3.new(1,0,1)
-    angle = 45*Math::PI/180
-    local_cod_x = Vector3.new(Math.cos(angle), Math.sin(angle),0)
-    x_vec = Vector3.new(1,0,0)
-    diff_angle = x_vec.angle(local_cod_x)
-    axis = x_vec.cross(local_cod_x).normalize()
-
-    rotate_matrix = Matrix.from_axis(axis, diff_angle)
-    rotated_point = rotate_matrix.inv * local_point
-    assert_equal(Vector3.new(Math.sqrt(2)/2, Math.sqrt(2)/2, 1), rotated_point)
-
-    local_point = Vector3.new(1,0,0)
-    local_cod_x = Vector3.new(1,1,1).normalize()
-    diff_angle = x_vec.angle(local_cod_x)
-    axis = x_vec.cross(local_cod_x).normalize()
-
-    assert_equal(Math::PI/2, local_cod_x.angle(axis))
-    rotate_matrix = Matrix.from_axis(axis, diff_angle)
-    rotated_point = rotate_matrix.inv()*local_point
-
-    assert_in_delta(rotated_point.x, rotated_point.y, rotated_point.tolerance)
-    assert_in_delta(rotated_point.x, rotated_point.z, rotated_point.tolerance)
-  end
-
-  def test_from_quat
-    axis = Vector3.new(1,2,4).normalize()
-    angle = 46*Math::PI/180
-    quat = Quat.from_axis(axis, angle)
-    mat_expected = Matrix.from_axis(axis, angle)
-    mat_actual = Matrix.from_quat(quat)
-
-    [0,1,2].each do |i|
-      [0,1,2].each do |j|
-        assert_in_delta( mat_expected[i,j], mat_actual[i,j], 1e-8)
-      end
-    end
-  end
-end
+# -*- coding: cp932 -*-
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'helper'
+
+include GMath3D
+
+MiniTest::Unit.autorun
+
+class MatrixTestCase < MiniTest::Unit::TestCase
+  def setup
+    @mat_default = Matrix.zero(3)
+    @mat = Matrix[[1,2,3],[4,5,6],[7,8,9]]
+  end
+
+  def test_initalize
+    @mat_default.each do |cell|
+      assert_equal(0, cell)
+    end
+
+    i = 1
+    @mat.each do |cell|
+      assert_equal(i, cell)
+      i+=1
+    end
+  end
+
+  def test_to_s
+    assert_equal("Matrix[[0, 0, 0], [0, 0, 0], [0, 0, 0]]", @mat_default.to_s)
+    assert_equal("Matrix[[1, 2, 3], [4, 5, 6], [7, 8, 9]]", @mat.to_s)
+  end
+
+  def test_multiply
+    mat = Matrix[[3,2,1],[-4,2,1],[3,4,1]]
+    vec = Matrix.column_vector([2,3,4])
+    ans = mat*vec
+
+    assert_equal(ans[0,0], 16)
+    assert_equal(ans[1,0], 2 )
+    assert_equal(ans[2,0], 22)
+
+    vec2 = Vector3.new(2,3,4)
+    ans2 = mat*(vec2)
+    assert_equal(Vector3.new(16,2,22), ans2)
+  end
+
+  def test_from_axis
+    local_point = Vector3.new(1,0,1)
+    angle = 45*Math::PI/180
+    local_cod_x = Vector3.new(Math.cos(angle), Math.sin(angle),0)
+    x_vec = Vector3.new(1,0,0)
+    diff_angle = x_vec.angle(local_cod_x)
+    axis = x_vec.cross(local_cod_x).normalize()
+
+    rotate_matrix = Matrix.from_axis(axis, diff_angle)
+    rotated_point = rotate_matrix.inv * local_point
+    assert_equal(Vector3.new(Math.sqrt(2)/2, Math.sqrt(2)/2, 1), rotated_point)
+
+    local_point = Vector3.new(1,0,0)
+    local_cod_x = Vector3.new(1,1,1).normalize()
+    diff_angle = x_vec.angle(local_cod_x)
+    axis = x_vec.cross(local_cod_x).normalize()
+
+    assert_equal(Math::PI/2, local_cod_x.angle(axis))
+    rotate_matrix = Matrix.from_axis(axis, diff_angle)
+    rotated_point = rotate_matrix.inv()*local_point
+
+    assert_in_delta(rotated_point.x, rotated_point.y, rotated_point.tolerance)
+    assert_in_delta(rotated_point.x, rotated_point.z, rotated_point.tolerance)
+  end
+
+  def test_from_quat
+    axis = Vector3.new(1,2,4).normalize()
+    angle = 46*Math::PI/180
+    quat = Quat.from_axis(axis, angle)
+    mat_expected = Matrix.from_axis(axis, angle)
+    mat_actual = Matrix.from_quat(quat)
+
+    [0,1,2].each do |i|
+      [0,1,2].each do |j|
+        assert_in_delta( mat_expected[i,j], mat_actual[i,j], 1e-8)
+      end
+    end
+  end
+end