gmath3D 0.2.2 → 0.2.3

data/VERSION

@@ -1 +1 @@
-0.2.2
+0.2.3

data/gmath3D.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{gmath3D}
-  s.version = "0.2.2"
+  s.version = "0.2.3"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Toshiyasu Shimizu"]
-  s.date = %q{2011-10-25}
+  s.date = %q{2011-11-03}
   s.description = %q{This library defines 3D geometric elements(point, line, plane etc..). It can get two(or more) elements relation, like distance between two elements.}
   s.email = %q{toshi0328@gmail.com}
   s.extra_rdoc_files = [
@@ -26,6 +26,7 @@ Gem::Specification.new do |s|
     "VERSION",
     "gmath3D.gemspec",
     "lib/box.rb",
+    "lib/ellipse.rb",
     "lib/finite_line.rb",
     "lib/geom.rb",
     "lib/gmath3D.rb",
@@ -41,6 +42,7 @@ Gem::Specification.new do |s|
     "lib/vector3.rb",
     "test/helper.rb",
     "test/test_box.rb",
+    "test/test_ellipse.rb",
     "test/test_finite_line.rb",
     "test/test_geom.rb",
     "test/test_line.rb",

data/lib/box.rb

@@ -28,6 +28,18 @@ public
       @max_point.z = [ point1.z, point2.z ].max
     end
 
+    # [Input]
+    #  _points_ should be Array of Vector3.
+    #  Each points are opposing corners.
+    # [Output]
+    #  return new instance of Box.
+    def self.from_points( points )
+      return nil if (points == nil || points.size <=0)
+      box = Box.new(points[0], points[0])
+      box += points
+      return box
+    end
+
     def to_s
       "Box[min#{min_point.to_element_s}, max#{max_point.to_element_s}]"
     end
@@ -71,6 +83,7 @@ private
       true
     end
     def add(rhs)
+      return self if (rhs == nil)
       if( rhs.kind_of?(Vector3))
         added_box = Box.new()
         added_box.min_point.x = [ self.min_point.x, rhs.x ].min

data/lib/ellipse.rb

@@ -0,0 +1,11 @@
+require 'gmath3D'
+
+module GMath3D
+  #
+  #
+  class Ellipse < Geom
+    def initialize(origin = Vector3.new(), axis1 = Vector3.new(1,0,0), axis2 = Vector3.new(0,1,0))
+      
+    end
+  end
+end

data/lib/finite_line.rb

@@ -9,11 +9,13 @@ public
     attr_accessor :start_point
     attr_accessor :end_point
 
+    include BoxAvailable
+
     # [Input]
     #  _start_point_ and _end_point_ should be Vector3.
     # [Output]
     #  return new instance as FiniteLine
-    def initialize(start_point = Vector3.new(0.0,0.0,0.0), end_point = Vector3.new(1.0,0.0,0.0))
+    def initialize(start_point = Vector3.new(0,0,0), end_point = Vector3.new(1,0,0))
       Util.check_arg_type(Vector3, start_point)
       Util.check_arg_type(Vector3, end_point)
       super()
@@ -30,6 +32,16 @@ public
       "FiniteLine[from#{start_point.to_element_s}, to#{end_point.to_element_s}]"
     end
 
+    # [Input]
+    #  _mat_ should be Matrix which row and col size are 3.
+    # [Output]
+    #  return rotated FiniteLine.
+    def rotate(mat)
+      rot_start_point = mat*start_point
+      rot_end_point = mat*end_point
+      return FiniteLine.new(rot_start_point, rot_end_point)
+    end
+
     # [Input]
     #  _rhs_ should be FiniteLine.
     # [Output]
@@ -42,6 +54,12 @@ public
       return true
     end
 
+    # [Output]
+    #  return Array of start_point and end_point.
+    def vertices
+      return [start_point, end_point]
+    end
+
     # [Output]
     #  return direction as vector from start_point to end_point as Vector3
     def direction

data/lib/gmath3D.rb

@@ -8,6 +8,8 @@ require 'matrix_util'
 
 require 'line'
 require 'finite_line'
+require 'ellipse'
+
 require 'plane'
 require 'rectangle'
 require 'triangle'

data/lib/polyline.rb

@@ -9,6 +9,8 @@ module GMath3D
     attr_accessor :vertices
     attr_accessor :is_open
 
+    include BoxAvailable
+
     # [Input]
     #  _vertices_ should be Array of Vector3.
     # [Output]

data/lib/rectangle.rb

@@ -12,6 +12,8 @@ public
     attr_accessor:u_vector
     attr_accessor:v_vector
 
+    include BoxAvailable
+
     # [Input]
     #  _base_point_ , _u_vector_, _v_vector_ should be Vector3.
     # _u_vector_ and _v_vector_ should be orthogonalized.

data/lib/tri_mesh.rb

@@ -8,6 +8,8 @@ module GMath3D
     attr_reader :vertices
     attr_reader :tri_indices
 
+    include BoxAvailable
+
     # [Input]
     #  vertices is Array of Vector3.
     #  tri_indices is Array of triangle whick is consist of 3 vertices index.
@@ -204,7 +206,7 @@ module GMath3D
       "TriMesh[triangle_count:#{tri_indices.size}, vertex_count:#{vertices.size}]"
     end
 
-    # [Input]
+   # [Input]
     #  _index_ is index of triangle.
     # [Output]
     #  return new instance of Triangle.

data/lib/triangle.rb

@@ -6,7 +6,9 @@ module GMath3D
   #
   class Triangle < Geom
 public
-    attr_accessor:vertices
+    attr_accessor :vertices
+
+    include BoxAvailable
 
     # [Input]
     #  _vertex1_, _vertex2_, _vertex3_ should be Vector3.

data/lib/util.rb

@@ -5,11 +5,20 @@ module GMath3D
         raise(ArgumentError::new("type mismatch: #{instance.class} for #{type}"))
       end
     end
-    
+
     def self.raise_argurment_error(instance)
       raise(ArgumentError::new("type mismatch: #{instance.class}"))
     end
   end
+
+  # Including 'vertices' methodshould be implimented that gets geometry vertices as Array of Vector3.
+  module BoxAvailable
+    # [Output]
+    #  return axially aligned bounding box as Box.
+    def box
+      return Box.from_points( vertices )
+    end
+  end
 end
 
 class Array

data/lib/vector3.rb

@@ -1,3 +1,4 @@
+# -*- coding: cp932 -*-
 require 'gmath3D'
 
 module GMath3D
@@ -49,6 +50,12 @@ public
       equals_inner(rhs)
     end
 
+    # [Output]
+    #  return axially aligned bounding box as Box.
+    def box
+      return Box.new(self, self)
+    end
+
     # [Input]
     #  _rhs_ should be Vector3.
     # [Output]
@@ -102,6 +109,23 @@ public
               self.x*rhs.y - self.y*rhs.x)
     end
 
+    # [Output]
+    #  return orthogonal vector as Vector3.
+    def arbitrary_orthogonal
+      return Vector3.new() if(self.length < self.tolerance)
+
+      if(!self.parallel?( Vector3.new(0.0, 1.0, 0.0) ))
+        un_parallel_vec = Vector3.new(0.0,1.0,0.0)
+      elsif(!self.parallel?( Vector3.new(0.0,0.0,1.0) ))
+        un_parallel_vec = Vector3.new(0.0,0.0,1.0)
+      else
+	un_parallel_vec = Vector3.new(1.0,0.0,0.0)
+      end
+
+      orthogonal = self.cross(un_parallel_vec)
+      return orthogonal.normalize
+    end
+
     # [Output]
     #  return vector length as Numeric
     def length

data/test/test_box.rb

@@ -40,6 +40,30 @@ class BoxTestCase < MiniTest::Unit::TestCase
     end
   end
 
+  def test_from_points
+    points = Array.new(6)
+    points[0] = Vector3.new( 3, 0,  1)
+    points[1] = Vector3.new( 2,-2, 10)
+    points[2] = Vector3.new(-6, 2, -4)
+    points[3] = Vector3.new( 3, 5, -1)
+    points[4] = Vector3.new(-2, 2,  2)
+    points[5] = Vector3.new(11, 1,  0)
+    box = Box.from_points(points)
+    assert_equal(Vector3.new(-6, -2, -4), box.min_point)
+    assert_equal(Vector3.new(11,  5, 10), box.max_point)
+
+    points = Array.new(2)
+    points[0] = Vector3.new( -3, -2,  -1)
+    points[1] = Vector3.new( -4, -8, -10)
+    box = Box.from_points(points)
+    assert_equal(Vector3.new(-4, -8, -10), box.min_point)
+    assert_equal(Vector3.new(-3, -2,  -1), box.max_point)
+
+    points = Array.new(0)
+    box = Box.from_points(points)
+    assert_equal(nil, box)
+  end
+
   def test_equal
     shallow_copied = @box
     assert( shallow_copied == @box )

data/test/test_ellipse.rb

@@ -0,0 +1,55 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'helper'
+
+include GMath3D
+
+MiniTest::Unit.autorun
+
+class EllipseTestCase < MiniTest::Unit::TestCase
+  def test_initialize
+  end
+
+  def test_to_s
+  end
+
+  def test_equals
+=begin
+   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)))
+
+    assert(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)))
+    assert(FiniteLine.new(Vector3.new(1,2,3), Vector3.new(2,3,3)) != FiniteLine.new(Vector3.new(1.0,2.0,3.0), Vector3.new(2.0,3.0,4.0)))
+    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)))
+    line = FiniteLine.new(Vector3.new(1,0,2), Vector3.new(1,-3.5,2))
+    assert_equal("FiniteLine[from[1, 0, 2], to[1, -3.5, 2]]", line.to_s)
+=end
+  end
+
+  def test_clone
+=begin
+    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
+  end
+
+
+end

data/test/test_finite_line.rb

@@ -24,6 +24,15 @@ class FiniteLineTestCase < MiniTest::Unit::TestCase
     assert_equal("FiniteLine[from[1, 0, 2], to[1, -3.5, 2]]", line.to_s)
   end
 
+  def test_rotation
+    line = FiniteLine.new(Vector3.new(1,0,0), Vector3.new(2,0,0))
+    angle = -45.0 * Math::PI / 180.0
+    mat = Matrix.from_axis( Vector3.new(0,0,1), angle )
+    rotated_line = line.rotate(mat)
+    assert_equal(Vector3.new(Math.sqrt(2)/2.0,Math.sqrt(2)/2.0,0), rotated_line.start_point)
+    assert_equal(Vector3.new(Math.sqrt(2),Math.sqrt(2),0), rotated_line.end_point)
+  end
+
   def test_equals
     line = FiniteLine.new()
     shallow_copied = line
@@ -57,6 +66,18 @@ class FiniteLineTestCase < MiniTest::Unit::TestCase
     assert_equal(-1, line.start_point.x) # original never changed in editing cloned one.
   end
 
+  def test_box
+    start_point_tmp = Vector3.new(1.0,  0.0, 2.0)
+    end_point_tmp   = Vector3.new(1.0, -3.5, 5.0)
+    line = FiniteLine.new(start_point_tmp, end_point_tmp)
+    assert_equal(Vector3.new(1, -3.5, 2), line.box.min_point)
+    assert_equal(Vector3.new(1,    0, 5), line.box.max_point)
+
+    line = FiniteLine.new()
+    assert_equal(Vector3.new(), line.box.min_point)
+    assert_equal(Vector3.new(1,0,0), line.box.max_point)
+  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_polyline.rb

@@ -79,6 +79,13 @@ class PolylineTestCase < MiniTest::Unit::TestCase
            @polyline_closed.to_s);
   end
 
+  def test_box
+    assert_equal(Vector3.new(0,0,0), @polyline_open.box.min_point)
+    assert_equal(Vector3.new(3,2,1), @polyline_open.box.max_point)
+    assert_equal(Vector3.new(0,0,0), @polyline_closed.box.min_point)
+    assert_equal(Vector3.new(3,2,1), @polyline_closed.box.max_point)
+  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)

data/test/test_rectangle.rb

@@ -61,6 +61,15 @@ class RectangleTestCase < MiniTest::Unit::TestCase
     assert_equal("Rectangle[base[1, 2, 3], u[0, -0.5, 0], v[0, 0, 2]", @rectangle.to_s)
   end
 
+  def test_box
+    box1 = @rectangle.box
+    box2 = @rectangle_default.box
+    assert_equal(Vector3.new(1, 1.5, 3), box1.min_point)
+    assert_equal(Vector3.new(1,   2, 5), box1.max_point)
+    assert_equal(Vector3.new(0,   0, 0), box2.min_point)
+    assert_equal(Vector3.new(1,   1, 0), box2.max_point)
+  end
+
   def test_point
     point = @rectangle.point(0.2, 1.0)
     assert_equal(Vector3.new(1, 1.9, 5), point)

data/test/test_tri_mesh.rb

@@ -88,6 +88,15 @@ class TriMeshTestCase < MiniTest::Unit::TestCase
     assert_equal( "TriMesh[triangle_count:12, vertex_count:8]", get_box_mesh().to_s)
   end
 
+  def test_box
+    box_mesh = get_box_mesh
+    plane_mesh = get_plane_mesh
+    assert_equal( Vector3.new(-1,-1,-1), box_mesh.box.min_point )
+    assert_equal( Vector3.new( 2, 3, 4), box_mesh.box.max_point )
+    assert_equal( Vector3.new(-1,-1,-1), plane_mesh.box.min_point )
+    assert_equal( Vector3.new( 1, 3,-1), plane_mesh.box.max_point )
+  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]]

data/test/test_triangle.rb

@@ -55,6 +55,15 @@ class TriangleTestCase < MiniTest::Unit::TestCase
     assert_equal("Triangle[[1, 2, 2], [1, 4, 2], [-1, 3, 0]]", @triangle.to_s)
   end
 
+  def test_box
+    box1 = @triangle.box
+    box2 = @triangle_default.box
+    assert_equal(Vector3.new(-1,2,0), box1.min_point)
+    assert_equal(Vector3.new(1,4,2), box1.max_point)
+    assert_equal(Vector3.new(0,0,0) , box2.min_point)
+    assert_equal(Vector3.new(1,1,0) , box2.max_point)
+  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])))

data/test/test_vector3.rb

@@ -144,6 +144,15 @@ class Vector3TestCase < MiniTest::Unit::TestCase
     assert_equal(3, hash[vec])
   end
 
+  def test_box
+    box1 = @vector.box
+    box2 = Vector3.new().box
+    assert_equal(Vector3.new(1,2,3), box1.min_point)
+    assert_equal(Vector3.new(1,2,3), box1.max_point)
+    assert_equal(Vector3.new(), box2.min_point)
+    assert_equal(Vector3.new(), box2.max_point)
+  end
+
   def test_add
     vector = Vector3.new(4,5,6)
     addedVector = vector + @vector
@@ -397,5 +406,34 @@ class Vector3TestCase < MiniTest::Unit::TestCase
     assert_equal( 0, matrix[2,0])
   end
 
-
+  def test_arbitrary_orthogonal
+    vec1 = Vector3.new( 1.0, 2.0, 3.0 )
+    vec2 = Vector3.new( 1.0, 1.0, 4.0 )
+    vec3 = Vector3.new( 2.0, 4.0, 6.0 )
+    vec4 = Vector3.new( -1.0, -2.0, -3.0 )
+    vecx = Vector3.new( 1.0,  0.0,  0.0 )
+    vecy = Vector3.new( 0.0, -3.0,  0.0 )
+    vecz = Vector3.new( 0.0,  0.0,  5.0 )
+    veczero = Vector3.new( 0.0,  0.0,  0.0 )
+
+    vec1_orth = vec1.arbitrary_orthogonal
+    vec2_orth = vec2.arbitrary_orthogonal
+    vec3_orth = vec3.arbitrary_orthogonal
+    vec4_orth = vec4.arbitrary_orthogonal
+    vecx_orth = vecx.arbitrary_orthogonal
+    vecy_orth = vecy.arbitrary_orthogonal
+    vecz_orth = vecz.arbitrary_orthogonal
+    veczero_orth = veczero.arbitrary_orthogonal
+
+    assert_in_delta(0.5*Math::PI, vec1.angle(vec1_orth), vec1.tolerance)
+    assert_in_delta(0.5*Math::PI, vec2.angle(vec2_orth), vec2.tolerance)
+    assert_in_delta(0.5*Math::PI, vec3.angle(vec3_orth), vec3.tolerance)
+    assert_in_delta(0.5*Math::PI, vec4.angle(vec4_orth), vec4.tolerance)
+    assert_in_delta(0.5*Math::PI, vecx.angle(vecx_orth), vecx.tolerance)
+    assert_in_delta(0.5*Math::PI, vecy.angle(vecy_orth), vecy.tolerance)
+    assert_in_delta(0.5*Math::PI, vecz.angle(vecz_orth), vecz.tolerance)
+    assert_in_delta(0.0, veczero_orth.x, veczero.tolerance)
+    assert_in_delta(0.0, veczero_orth.y, veczero.tolerance)
+    assert_in_delta(0.0, veczero_orth.z, veczero.tolerance)
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: gmath3D
 version: !ruby/object:Gem::Version
-  version: 0.2.2
+  version: 0.2.3
   prerelease: 
 platform: ruby
 authors:
@@ -9,12 +9,12 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-10-25 00:00:00.000000000 +09:00
+date: 2011-11-03 00:00:00.000000000 +09:00
 default_executable: 
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
-  requirement: &2152196520 !ruby/object:Gem::Requirement
+  requirement: &2156037040 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -22,10 +22,10 @@ dependencies:
         version: 1.0.0
   type: :development
   prerelease: false
-  version_requirements: *2152196520
+  version_requirements: *2156037040
 - !ruby/object:Gem::Dependency
   name: jeweler
-  requirement: &2152195120 !ruby/object:Gem::Requirement
+  requirement: &2156035880 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -33,7 +33,7 @@ dependencies:
         version: 1.6.4
   type: :development
   prerelease: false
-  version_requirements: *2152195120
+  version_requirements: *2156035880
 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
@@ -52,6 +52,7 @@ files:
 - VERSION
 - gmath3D.gemspec
 - lib/box.rb
+- lib/ellipse.rb
 - lib/finite_line.rb
 - lib/geom.rb
 - lib/gmath3D.rb
@@ -67,6 +68,7 @@ files:
 - lib/vector3.rb
 - test/helper.rb
 - test/test_box.rb
+- test/test_ellipse.rb
 - test/test_finite_line.rb
 - test/test_geom.rb
 - test/test_line.rb
@@ -95,7 +97,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -2118171931574002143
+      hash: 3556461112353261793
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements: