gmath3D 0.1.1

data/lib/rectangle.rb

@@ -0,0 +1,89 @@
+require 'matrix'
+
+require 'gmath3D'
+
+module GMath3D
+  class Rectangle < Geom
+public
+    attr_accessor:base_point
+    attr_accessor:u_vector
+    attr_accessor:v_vector
+
+    def initialize(base_point_arg = Vector3.new(), u_vector_arg = Vector3.new(1,0,0), v_vector_arg = Vector3.new(0,1,0))
+      Util.check_arg_type(::Vector3, base_point_arg)
+      Util.check_arg_type(::Vector3, u_vector_arg)
+      Util.check_arg_type(::Vector3, v_vector_arg)
+      super()
+      self.base_point = base_point_arg
+      self.u_vector = u_vector_arg
+      self.v_vector = v_vector_arg
+    end
+
+    def point(u, v)
+      Util.check_arg_type(::Numeric, u)
+      Util.check_arg_type(::Numeric, v)
+      return base_point + u_vector*u + v_vector*v
+    end
+
+    def edges
+      edge_ary = Array.new(4)
+      edge_ary[0] = FiniteLine.new( base_point, base_point+u_vector)
+      edge_ary[1] = FiniteLine.new( base_point+u_vector, base_point+u_vector+v_vector)
+      edge_ary[2] = FiniteLine.new( base_point+u_vector+v_vector, base_point+v_vector)
+      edge_ary[3] = FiniteLine.new( base_point+v_vector, base_point)
+      return edge_ary
+    end
+
+    def normal
+      return (u_vector.cross(v_vector)).normalize()
+    end
+
+    def opposite_point
+      return base_point + u_vector + v_vector
+    end
+
+    def center_point
+      return base_point + u_vector*0.5 + v_vector*0.5
+    end
+
+    def area
+      return (u_vector.cross(v_vector)).length
+    end
+
+    def uv_parameter(check_point)
+      Util.check_arg_type(::Vector3, check_point)
+      mat = Matrix[[u_vector.x, u_vector.y, u_vector.z],
+            [v_vector.x, v_vector.y, v_vector.z],
+            [normal.x, normal.y, normal.z]]
+      vec = (check_point - base_point).to_column_vector
+      ans = mat.t.inv*vec
+      return ans[0,0], ans[1,0]
+    end
+
+    def distance(target)
+      # with Point
+      if(target.kind_of?(Vector3))
+        return distance_to_point(target)
+      elsif(target.kind_of?(Line))
+        #with Line
+#        return distance_to_line(target)
+      end
+      Util.raise_argurment_error(target)
+    end
+
+private
+    def distance_to_point(check_point)
+      u,v = self.uv_parameter(check_point)
+      if(u >= 0 && u <= 1 && v >= 0 && v <= 1)
+        point_on_rect = self.point( u, v )
+        distance = point_on_rect.distance(check_point)
+        return distance, point_on_rect
+      end
+      # rectangle does not contain projected point
+      # check distance to FiniteLines
+      finite_lines = self.edges
+      return FiniteLine.ary_distanc_to_point(finite_lines, check_point)
+    end
+  end
+end
+

data/lib/triangle.rb

@@ -0,0 +1,133 @@
+require 'gmath3D'
+
+module GMath3D
+  class Triangle < Geom
+public
+    attr_accessor:vertices
+
+    def initialize(vertex_arg1 = Vector3.new(), vertex_arg2 = Vector3.new(1,0,0), vertex_arg3 = Vector3.new(0,1,0))
+      Util.check_arg_type(::Vector3, vertex_arg1)
+      Util.check_arg_type(::Vector3, vertex_arg2)
+      Util.check_arg_type(::Vector3, vertex_arg3)
+      super()
+      @vertices = Array.new([vertex_arg1, vertex_arg2, vertex_arg3])
+    end
+
+    def point( parameter )
+      Util.check_arg_type(::Array, parameter )
+      # TODO Argument check
+      return self.vertices[0]*parameter[0] + self.vertices[1]*parameter[1] + self.vertices[2]*parameter[2]
+    end
+
+    def edges
+      return_edges = Array.new(3)
+      return_edges[0] = FiniteLine.new(self.vertices[0], self.vertices[1])
+      return_edges[1] = FiniteLine.new(self.vertices[1], self.vertices[2])
+      return_edges[2] = FiniteLine.new(self.vertices[2], self.vertices[0])
+      return return_edges
+    end
+
+    def area
+      vec1 = vertices[1] - vertices[0]
+      vec2 = vertices[2] - vertices[0]
+      outer_product = vec1.cross(vec2)
+      return outer_product.length / 2.0
+    end
+
+    def center
+      return vertices.avg
+    end
+
+    def normal
+      vec1 = self.vertices[1] - self.vertices[0]
+      vec2 = self.vertices[2] - self.vertices[0]
+      return (vec1.cross(vec2).normalize)
+    end
+
+    def barycentric_coordinate( check_point )
+      Util.check_arg_type(::Vector3, check_point)
+
+      v0 = @vertices[0]
+      v1 = @vertices[1]
+      v2 = @vertices[2]
+
+      d1 = v1 - v0
+      d2 = v2 - v1
+      n = d1.cross(d2);
+      if((n.x).abs >= (n.y).abs && (n.x).abs >= (n.z).abs)
+        uu1 = v0.y - v2.y;
+        uu2 = v1.y - v2.y;
+        uu3 = check_point.y  - v0.y;
+        uu4 = check_point.y  - v2.y;
+        vv1 = v0.z - v2.z;
+        vv2 = v1.z - v2.z;
+        vv3 = check_point.z  - v0.z;
+        vv4 = check_point.z  - v2.z;
+      elsif((n.y).abs >= (n.z).abs)
+        uu1 = v0.z - v2.z;
+        uu2 = v1.z - v2.z;
+        uu3 = check_point.z  - v0.z;
+        uu4 = check_point.z  - v2.z;
+        vv1 = v0.x - v2.x;
+        vv2 = v1.x - v2.x;
+        vv3 = check_point.x  - v0.x;
+        vv4 = check_point.x  - v2.x;
+      else
+        uu1 = v0.x - v2.x;
+        uu2 = v1.x - v2.x;
+        uu3 = check_point.x  - v0.x;
+        uu4 = check_point.x  - v2.x;
+        vv1 = v0.y - v2.y;
+        vv2 = v1.y - v2.y;
+        vv3 = check_point.y  - v0.y;
+        vv4 = check_point.y  - v2.y;
+      end
+
+      denom = vv1 * uu2 - vv2* uu1
+      if(denom == 0.0)
+	return nil
+      end
+      b = Array.new(3)
+      oneOverDenom = 1.0 / denom ;
+      b[0] = (vv4*uu2 - vv2*uu4) * oneOverDenom;
+      b[1] = (vv1*uu3 - vv3*uu1) * oneOverDenom;
+      b[2] = 1.0 - b[0] - b[1];
+      return b;
+    end
+
+    def distance(target)
+      # with Point
+      if(target.kind_of?(Vector3))
+        return distance_to_point(target)
+      elsif(target.kind_of?(Line))
+        #with Line
+#        return distance_to_line(target)
+      end
+      Util.raise_argurment_error(target)
+    end
+
+    def contains( check_point )
+      Util.check_arg_type(Vector3, check_point )
+      plane = Plane.new( vertices[0], self.normal)
+      distance, projected_point = plane.distance(check_point)
+      return false if( distance > self.tolerance )
+      g_coord = self.barycentric_coordinate(check_point)
+      g_coord.each do |item|
+        return false if( item < 0 or 1 < item)
+      end
+      return true
+    end
+private
+    def distance_to_point(target_point)
+      plane = Plane.new( vertices[0], self.normal)
+      distance, projected_point = plane.distance(target_point)
+      if( self.contains(projected_point))
+        return distance, projected_point
+      end
+      #check distance to FiniteLines
+      finite_lines = self.edges
+      return FiniteLine.ary_distanc_to_point(finite_lines, target_point)
+    end
+  end
+end
+

data/lib/util.rb

@@ -0,0 +1,41 @@
+module GMath3D
+  class Util
+    def self.check_arg_type(type, instance)
+      unless(instance.kind_of?(type))
+        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
+end
+
+class Array
+public
+  def sum
+    s, n = self.sum_with_number
+    return s
+  end
+  def avg
+    s, n = self.sum_with_number
+    return s / n
+  end
+
+  def sum_with_number
+    return nil, 0 if(self.size <= 0)
+    s = nil
+    n = 0
+    self.each do |v|
+      next if v.nil?
+      if(s==nil)
+        s = v
+      else
+        s += v
+      end
+      n += 1
+    end
+    return s, n
+  end
+end

data/lib/vector3.rb

@@ -0,0 +1,116 @@
+require 'gmath3D'
+
+module GMath3D
+  class Vector3 < Geom
+public
+    attr_accessor :x
+    attr_accessor :y
+    attr_accessor :z
+
+    def initialize(x=0.0,y=0.0,z=0.0)
+      super()
+      @x = x
+      @y = y
+      @z = z
+    end
+    def ==(rhs)
+      equals_inner(rhs)
+    end
+    def +(rhs)
+      add(rhs)
+    end
+    def -(rhs)
+      subtract(rhs)
+    end
+    def *(rhs)
+      multiply(rhs)
+    end
+    def /(rhs)
+      divide(rhs)
+    end
+
+    def dot(rhs)
+      Util.check_arg_type(Vector3, rhs)
+      self.x*rhs.x + self.y*rhs.y + self.z*rhs.z
+    end
+    def cross(rhs)
+      Util.check_arg_type(Vector3, rhs)
+      Vector3.new(
+              self.y*rhs.z - self.z*rhs.y,
+              self.z*rhs.x - self.x*rhs.z,
+              self.x*rhs.y - self.y*rhs.x)
+    end
+
+    def length
+      Math::sqrt(self.x*self.x + self.y*self.y + self.z*self.z)
+    end
+    def distance(rhs)
+      Util.check_arg_type(Vector3, rhs)
+      Math::sqrt((self.x - rhs.x)*(self.x - rhs.x) + (self.y - rhs.y)*(self.y - rhs.y) + (self.z - rhs.z)*(self.z - rhs.z))
+    end
+    def distance(rhs)
+      Util.check_arg_type(Vector3, rhs)
+      Math::sqrt((self.x - rhs.x)*(self.x - rhs.x) + (self.y - rhs.y)*(self.y - rhs.y) + (self.z - rhs.z)*(self.z - rhs.z))
+    end
+
+    def angle(rhs)
+      Util.check_arg_type(Vector3, rhs)
+      vec1Length = self.length ;
+      vec2Length = rhs.length   ;
+      return 0.0 if(vec1Length*vec2Length < self.tolerance )
+      v = self.dot(rhs)/(vec1Length*vec2Length)
+      Math::acos( v )
+    end
+    def normalize()
+      self / self.length.to_f
+    end
+
+    def parallel?(rhs)
+      Util.check_arg_type(Vector3, rhs)
+      return false if(self.length < self.tolerance or rhs.length < rhs.tolerance)
+      return false if(self.cross(rhs).length > self.tolerance)
+      return true
+    end
+    def same_direction?(rhs)
+      Util.check_arg_type(Vector3, rhs)
+      return false if(!parallel?(rhs))
+      return false if(self.dot(rhs) < self.tolerance)
+      return true
+    end
+
+    def project_to(rhs)
+      Util.check_arg_type(Vector3, rhs)
+      return Vector3.new, 0.0 if( rhs.length < rhs.tolerance )
+      parameter = self.dot( rhs ) / ( rhs.x * rhs.x + rhs.y * rhs.y + rhs.z * rhs.z ).to_f
+      return rhs*parameter, parameter
+    end
+    def to_column_vector
+      return Matrix.column_vector([x,y,z])
+    end
+    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) 
+      true
+    end
+    def add(rhs)
+      Util.check_arg_type(Vector3, rhs)
+      Vector3.new(self.x + rhs.x, self.y + rhs.y, self.z + rhs.z)
+    end
+    def subtract(rhs)
+      Util.check_arg_type(Vector3, rhs)
+      Vector3.new(self.x - rhs.x, self.y - rhs.y, self.z - rhs.z)
+    end
+    def multiply(rhs)
+      Util.check_arg_type(::Numeric, rhs)
+      Vector3.new(self.x * rhs, self.y * rhs, self.z * rhs)
+    end
+    def divide(rhs)
+      Util.check_arg_type(::Numeric, rhs)
+      Vector3.new(self.x.to_f / rhs, self.y / rhs.to_f, self.z / rhs.to_f)
+    end
+  end
+end
+

data/test/helper.rb

@@ -0,0 +1,15 @@
+require 'rubygems'
+require 'bundler'
+
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'minitest/unit'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+
+require 'gmath3D'

data/test/test_box.rb

@@ -0,0 +1,90 @@
+require 'box'
+
+include GMath3D
+
+MiniTest::Unit.autorun
+
+class BoxTestCase < MiniTest::Unit::TestCase
+  def setup
+    @box_default = Box.new()
+    @box = Box.new(Vector3.new(-3,2,5), Vector3.new(2,-2.5, 0))
+  end
+
+  def test_initalize
+    assert_equal(0, @box_default.min_point.x)
+    assert_equal(0, @box_default.min_point.y)
+    assert_equal(0, @box_default.min_point.z)
+    assert_equal(1, @box_default.max_point.x)
+    assert_equal(1, @box_default.max_point.y)
+    assert_equal(1, @box_default.max_point.z)
+
+    assert_equal(-3.0, @box.min_point.x)
+    assert_equal(-2.5, @box.min_point.y)
+    assert_equal(0.0 , @box.min_point.z)
+    assert_equal(2.0 , @box.max_point.x)
+    assert_equal(2.0 , @box.max_point.y)
+    assert_equal(5.0 , @box.max_point.z)
+
+    assert_equal(Geom.default_tolerance, @box_default.tolerance)
+
+    assert_raises ArgumentError do
+      invalidResult = Box.new(nil)
+    end
+    assert_raises ArgumentError do
+      invalidResult = Box.new(Vector3.new(), 4.0)
+    end
+  end
+
+  def test_equal
+    shallow_copied = @box
+    assert( shallow_copied == @box )
+    assert( shallow_copied.equal?( @box ) )
+
+    deep_copied = Box.new(Vector3.new(-3,2,5), Vector3.new(2,-2.5, 0))
+    assert( deep_copied == @box )
+    assert( !deep_copied.equal?( @box ) )
+
+    assert( @box != 5 )
+  end
+
+  def test_add
+    added_box = @box_default + Vector3.new(-2, 0.5, 3)
+    assert_equal(Vector3.new(-2,0,0), added_box.min_point)
+    assert_equal(Vector3.new(1,1,3) , added_box.max_point)
+
+    added_box = @box_default + Box.new( Vector3.new(-2,0.5, 3), Vector3.new(4, 0, 2.0))
+    assert_equal(Vector3.new(-2,0,0), added_box.min_point)
+    assert_equal(Vector3.new(4,1,3) , added_box.max_point)
+
+    point_ary = [Vector3.new(1,4,9), Vector3.new(4,-2,4), Vector3.new(2,-5,0)]
+    added_box = @box + point_ary
+    assert_equal(Vector3.new(-3,-5, 0), added_box.min_point)
+    assert_equal(Vector3.new( 4, 4, 9), added_box.max_point)
+
+    assert_raises ArgumentError do
+      invalidResult = @box + 4
+    end
+  end
+
+  def test_center
+    assert_equal( Vector3.new(0.5, 0.5, 0.5), @box_default.center)
+    assert_equal( Vector3.new(-0.5,-0.25,2.5), @box.center)
+  end
+
+  def test_length
+    width, height, depth = @box_default.length
+    assert_in_delta( 1, width , @box_default.tolerance)
+    assert_in_delta( 1, height, @box_default.tolerance)
+    assert_in_delta( 1, depth , @box_default.tolerance)
+
+    width, height, depth = @box.length
+    assert_in_delta( 5.0, width , @box.tolerance)
+    assert_in_delta( 4.5, height, @box.tolerance)
+    assert_in_delta( 5.0, depth , @box.tolerance)
+  end
+
+  def test_volume
+    assert_in_delta( 1.0, @box_default.volume, @box_default.tolerance )
+    assert_in_delta( 112.5, @box.volume, @box.tolerance )
+  end
+end