geom 0.0.1

data/.gitignore

@@ -0,0 +1,18 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+coverage

data/Gemfile

@@ -0,0 +1,8 @@
+source 'http://rubygems.org'
+
+# Specify your gem's dependencies in geom.gemspec
+gemspec
+
+gem 'rspec'
+gem 'shoulda'
+gem 'simplecov', :require => false

data/Rakefile

@@ -0,0 +1,2 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"

data/geom.gemspec

@@ -0,0 +1,17 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/geom/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Adrian Smith"]
+  gem.email         = ["adrian.smith@ennova.com.au"]
+  gem.description   = "A 3D geometry library that includes Point, Vector, Line, Plane, Coordinate System and Transformation objects"
+  gem.summary       = "A 3D geometry library"
+  gem.homepage      = "https://github.com/AdrianSmith/geom"
+
+  gem.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  gem.files         = `git ls-files`.split("\n")
+  gem.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  gem.name          = "geom"
+  gem.require_paths = ["lib"]
+  gem.version       = Geom::VERSION
+end

data/lib/geom/line.rb

@@ -0,0 +1,118 @@
+module Geom
+  # Line defined by parametric equations X = X0 + XAt, Y = Y0 + YAt, ,Z = Z0 + ZAt
+  class Line
+    attr_accessor :x0, :xa, :y0, :ya, :z0, :za
+
+    def initialize(*args)
+
+      case args.size
+      when 2 # Start point and End point
+        start_point = args[0]
+        end_point = args[1]
+
+        line_direction = Vector.new(start_point, end_point)
+
+        @x0 = start_point.x
+        @y0 = start_point.y
+        @z0 = start_point.z
+        @xa = line_direction.x
+        @ya = line_direction.y
+        @za = line_direction.z
+
+      else # Coefficients of line equation
+        @x0, @xa, @y0, @ya, @z0, @za = args.flatten
+      end
+    end
+
+    def ==(line)
+      (@x0 - line.x0).abs < TOLERANCE &&
+      (@y0 - line.y0).abs < TOLERANCE &&
+      (@z0 - line.z0).abs < TOLERANCE &&
+      (@xa - line.xa).abs < TOLERANCE &&
+      (@ya - line.ya).abs < TOLERANCE &&
+      (@za - line.za).abs < TOLERANCE
+    end
+
+    alias_method :eql?, :==
+
+    def hash
+      (@x0.to_int ^ @y0.to_int ^ @z0.to_int ^ @xa.to_int ^ @ya.to_int ^ @za.to_int)
+    end
+
+    def direction
+      Vector.new(point_at_parameter(0), point_at_parameter(1))
+    end
+
+    def point_at_parameter(t)
+      Point.new((@x0 + @xa * t), (@y0 + @ya * t), (@z0 + @za * t))
+    end
+
+    def parameter_at_point(point)
+      if (@xa != 0)
+        ((point.x - @x0) / @xa)
+      elsif (@ya != 0)
+        ((point.y - @y0) / @ya)
+      else
+        ((point.z - @z0) / @za)
+      end
+    end
+
+    def closest_approach_parameter(line)
+      if self.direction.parallel?(line.direction)
+        raise ArgumentError.new("Lines are parallel")
+      else
+        s1 = Vector.new(@x0, @y0, @z0)
+        v1 = Vector.new(@xa, @ya, @za)
+        s2 = Vector.new(line.x0, line.y0, line.z0)
+        v2 = Vector.new(line.xa, line.ya, line.za)
+
+        i = 1 / ((v1.dot(v2) * v1.dot(v2)) - (v1.length * v1.length) * (v2.length * v2.length))
+        j11 = -(v2.length * v2.length)
+        j12 = v1.dot(v2)
+
+        vk = Vector.new(s1, s2)
+
+        k1 = vk.dot(v1)
+        k2 = vk.dot(v2)
+
+        i * (j11 * k1 + j12 * k2)
+      end
+    end
+
+    def intersection_with_line(line)
+      t1 = self.closest_approach_parameter(line)
+      t2 = line.closest_approach_parameter(self)
+
+      p1 = self.point_at_parameter(t1)
+      p2 = line.point_at_parameter(t2)
+
+      dist = p1.distance_to_point(p2)
+
+      if (dist < TOLERANCE)
+        p1
+      else
+        raise ArgumentError.new("Lines do not intersect")
+      end
+    end
+
+    def intersection_with_plane(plane)
+      var = [0,0]
+      var[0] = @x0 * plane.a + @y0 * plane.b + @z0 * plane.c
+      var[1] = @xa * plane.a + @ya * plane.b + @za * plane.c
+
+      raise ArgumentError.new("Line is parallel to the plane") if var[1] == 0
+
+      t = (plane.d - var[0]) / var[1]
+      Point.new((@x0 + @xa * t), (@y0 + @ya * t), (@z0 + @za * t))
+    end
+
+    def on_plane?(plane)
+      self.point_at_parameter(0).on_plane?(plane) && self.point_at_parameter(1).on_plane?(plane)
+    end
+
+    def to_s
+      "Line(%.3f,%.3f,%.3f,%.3f,%.3f,%.3f)" % [@x0, @xa, @y0, @ya, @z0, @za]
+    end
+
+  end
+end

data/lib/geom/plane.rb

@@ -0,0 +1,71 @@
+module Geom
+  # Plane defined by the equation:Ax + By + Cz = D
+  class Plane
+    attr_accessor :a, :b, :c, :d
+
+    def initialize(*args)
+
+      case args.size
+      when 2 # Point and normal vector
+        point = args[0]
+        normal = args[1]
+
+        @a = normal.x
+        @b = normal.y
+        @c = normal.z
+        @d = ((normal.x * point.x) + ((normal.y * point.y) + (normal.z * point.z)))
+
+      when 3 # Points on the plane
+        point_1 = args[0]
+        point_2 = args[1]
+        point_3 = args[2]
+
+        vector_12 = Vector.new(point_1, point_2)
+        vector_13 = Vector.new(point_1, point_3)
+        plane_normal = vector_12.cross(vector_13)
+
+        @a = plane_normal.x
+        @b = plane_normal.y
+        @c = plane_normal.z
+        @d = ((point_1.x * @a) + ((point_1.y * @b) + (point_1.z * @c)))
+
+      else # Coefficients of plane equation
+        @a, @b, @c, @d = args.flatten
+      end
+      self.normalize
+    end
+
+    def ==(plane)
+      (@a - plane.a).abs < TOLERANCE &&
+      (@b - plane.b).abs < TOLERANCE &&
+      (@c - plane.c).abs < TOLERANCE &&
+      (@d - plane.d).abs < TOLERANCE
+    end
+    alias_method :eql?, :==
+
+    def hash
+      (@a.to_int ^ @b.to_int ^ @c.to_int ^ @d.to_int)
+    end
+
+    def normal
+      Vector.new(@a, @b, @c).unitize
+    end
+
+    def to_s
+      "Plane(%.3f,%.3f,%.3f,%.3f)" % [@a, @b, @c, @d]
+    end
+
+    def normalize
+      if (@a == 0 && @b == 0 && @c == 0)
+        raise ArgumentError, "Plane definition error, points may be coincident or collinear"
+      else
+        norm_factor = 1.0 / Math.sqrt((@a * @a + @b * @b + @c * @c))
+        @a *= norm_factor
+        @b *= norm_factor
+        @c *= norm_factor
+        @d *= norm_factor
+      end
+    end
+
+  end
+end

data/lib/geom/point.rb

@@ -0,0 +1,148 @@
+module Geom
+  # Point defined by coordinates x, y, z
+  class Point
+    attr_accessor :x, :y, :z
+
+    def initialize(*args)
+      @x, @y, @z = args.flatten
+    end
+
+    def -(point)
+      Point.new(@x - point.x, @y - point.y, @z - point.z)
+    end
+
+    def +(point)
+      Point.new(@x + point.x, @y + point.y, @z + point.z)
+    end
+
+    def ==(point)
+      (@x - point.x).abs < TOLERANCE &&
+      (@y - point.y).abs < TOLERANCE &&
+      (@z - point.z).abs < TOLERANCE
+    end
+    alias_method :eql?, :==
+    alias_method :coincident?, :==
+
+    def hash
+      (@x.to_int ^ @y.to_int ^ @z.to_int)
+    end
+
+    def distance_to_point(point)
+      x_dist = @x - point.x
+      y_dist = @y - point.y
+      z_dist = @z - point.z
+      Math.sqrt(x_dist * x_dist + y_dist * y_dist + z_dist * z_dist)
+    end
+
+    def distance_to_plane(plane)
+      n = Vector.new(plane.a, plane.b, plane.c)
+      l = n.length
+      d = (plane.d / (l * l))
+      pnt = Point.new((plane.a * d), (plane.b * d), (plane.c * d))
+      vec = Vector.new(self, pnt)
+      vec.dot(n) / l
+    end
+
+    def translate(direction, distance=1)
+      transation_vector = direction.unitize.scale distance
+      Point.new(@x + transation_vector.x, @y + transation_vector.y, @z + transation_vector.z)
+    end
+
+    def transform(rectangular_coordinate_system)
+      m = Transformation.new(rectangular_coordinate_system).matrix
+      tx = m[0,0] * @x + m[0,1] * @y + m[0,2] * @z + m[0,3] * 1.0
+      ty = m[1,0] * @x + m[1,1] * @y + m[1,2] * @z + m[1,3] * 1.0
+      tz = m[2,0] * @x + m[2,1] * @y + m[2,2] * @z + m[2,3] * 1.0
+      Point.new(tx, ty, tz)
+    end
+
+    def project_onto_line(line)
+      l = line.xa * line.xa + line.ya * line.ya + line.za * line.za
+      m = 2 * (line.x0 - self.x) * line.xa + 2 * (line.y0 - self.y) * line.ya + 2 * (line.z0 - self.z) * line.za
+      t = -m / (2 * l)
+      Point.new(line.x0 + line.xa * t, line.y0 + line.ya * t, line.z0 + line.za * t)
+    end
+
+    def project_onto_line_along_vector(line, vector)
+      ref_line = Line.new(@x, vector.x, @y, vector.y, @z, vector.z)
+      line.intersection_with_line(ref_line)
+    end
+
+    def project_onto_plane(plane)
+      n = plane.normal
+      q = self.to_vector
+
+      r = (q.dot(n) - plane.d) / n.length
+
+      result = q - n.unitize.scale(r)
+      result.to_point
+    end
+
+    def project_onto_plane_along_vector(plane, vector)
+
+      l = Math.sqrt(plane.a * plane.a + plane.b * plane.b + plane.c * plane.c)
+      d = (plane.d / (l * l))
+      q = Point.new((plane.a * d), (plane.b * d), (plane.c * d))
+      v = Vector.new(q, self)
+
+      u = plane.normal
+      w = vector.scale((v.dot(u) / vector.dot(u)))
+      r = q.to_vector + (v - w)
+
+      r.to_point
+    end
+
+    def between?(first_point, second_point, include_ends=true)
+      line = Line.new(first_point, second_point)
+      projected_point = self.project_onto_line(line)
+
+      distance_12 = first_point.distance_to_point(second_point)
+      distance_T1 = first_point.distance_to_point(projected_point)
+      distance_T2 = second_point.distance_to_point(projected_point)
+
+      if include_ends
+        (distance_T1 < distance_12) && (distance_T2 < distance_12)
+      else
+        (distance_T1 <= distance_12) && (distance_T2 <= distance_12)
+      end
+    end
+
+    def on_plane?(plane)
+      projected_point = self.project_onto_plane(plane)
+      projected_point.distance_to_point(self).abs <= TOLERANCE
+    end
+
+    def on_line?(line)
+      projected_point = self.project_onto_line(line)
+      self.Distance(projected_point) <= Tolerance
+    end
+
+    def self.remove_coincident(points)
+      points.uniq
+    end
+
+    def self.average(points)
+      tx, ty, tz = 0, 0, 0
+      num = points.size.to_f
+      points.each do |point|
+        tx += point.x
+        ty += point.y
+        tz += point.z
+      end
+      Point.new(tx/num, ty/num, tz/num)
+    end
+
+    def to_vector
+      Vector.new(@x,@y,@z)
+    end
+
+    def to_s
+      "Point(%.3f,%.3f,%.3f)" % [@x, @y, @z]
+    end
+
+    def to_a
+      [@x, @y, @z]
+    end
+
+  end
+end

data/lib/geom/rectangular_coordinate_system.rb

@@ -0,0 +1,77 @@
+module Geom
+  class RectangularCoordinateSystem
+    attr_accessor :origin, :x_vector, :y_vector, :z_vector
+
+    def initialize
+      @origin = Point.new(0.0, 0.0, 0.0)
+      @x_vector = Vector.new(1.0, 0.0, 0.0)
+      @y_vector = Vector.new(0.0, 1.0, 0.0)
+      @z_vector = Vector.new(0.0, 0.0, 1.0)
+    end
+
+    def self.new_from_xvector_and_xyplane(origin, axis_vector, plane_vector)
+      rcs = self.new
+      rcs.origin = origin
+      rcs.x_vector = axis_vector.unitize
+      rcs.z_vector = plane_vector.unitize
+      rcs.y_vector = rcs.z_vector.cross(rcs.x_vector).unitize
+      rcs.z_vector = rcs.x_vector.cross(rcs.y_vector).unitize
+      rcs
+    end
+
+    def self.new_from_yvector_and_yzplane(origin, axis_vector, plane_vector)
+      rcs = self.new
+      rcs.origin = origin
+      rcs.y_vector = axis_vector.unitize
+      rcs.x_vector = plane_vector.unitize
+      rcs.z_vector = rcs.x_vector.cross(rcs.y_vector).unitize
+      rcs.x_vector = rcs.y_vector.cross(rcs.z_vector).unitize
+      rcs
+    end
+
+    def self.new_from_zvector_and_zxplane(origin, axis_vector, plane_vector)
+      rcs = self.new
+      rcs.origin = origin
+      rcs.z_vector = axis_vector.unitize
+      rcs.y_vector = plane_vector.unitize
+      rcs.x_vector = rcs.y_vector.cross(rcs.z_vector).unitize
+      rcs.y_vector = rcs.z_vector.cross(rcs.x_vector).unitize
+      rcs
+    end
+
+    def transformation_matrix
+      Matrix[
+        [@x_vector.x, @y_vector.x, @z_vector.x, @origin.x],
+        [@x_vector.y, @y_vector.y, @z_vector.y, @origin.y],
+        [@x_vector.z, @y_vector.z, @z_vector.z, @origin.z],
+        [0.0, 0.0, 0.0, 1.0]
+      ]
+    end
+
+    def to_s(verbose=false)
+      unless verbose
+        "RCS[#{@origin.to_s} X-#{@x_vector.to_s} Y-#{@y_vector.to_s} Z-#{@z_vector.to_s}]"
+      else
+        str = "Rectangular Coordinate System\n"
+        str += "Origin:    #{@origin.to_s}\n"
+        str += "X-Vector: #{@x_vector.to_s}\n"
+        str += "Y-Vector: #{@y_vector.to_s}\n"
+        str += "Z-Vector: #{@z_vector.to_s}"
+        str
+      end
+    end
+
+    def == rcs
+      rcs.x_vector == @x_vector &&
+      rcs.y_vector == @y_vector &&
+      rcs.z_vector == @z_vector &&
+      rcs.origin == @origin
+    end
+
+    alias_method :eql?, :==
+
+    def hash
+      (@x_vector.hash ^ @y_vector.hash ^ @z_vector.hash ^ @origin.hash)
+    end
+  end
+end

data/lib/geom/tolerance.rb

@@ -0,0 +1,3 @@
+module Geom
+  TOLERANCE = 10 ** -12
+end

data/lib/geom/transformation.rb

@@ -0,0 +1,93 @@
+module Geom
+  # 3D transformation object that is composed of a 4x4 matrix representing the
+  # rotation and translation components
+  # rx1  ry1  rz1  tx
+  # rx2  ry2  rz2  ty
+  # rx3  ry3  rz3  tz
+  #   0    0    0   1
+  # Transformations are applied by using the * operator
+  # Available transformations include translation and rotation
+  class Transformation
+    attr_accessor :type, :matrix, :translation_vector
+
+    TRANSLATION = 1
+    ROTATION = 2
+    SCALING = 4
+
+    def initialize(coordinate_system)
+      @matrix = coordinate_system.transformation_matrix.inverse * 1.0 # ensure initialization as float not integer
+      @translation_vector = Vector.new(Point.new(0.0, 0.0, 0.0), coordinate_system.origin)
+      @type = 0 # initialize as integer not boolean
+
+      @type |= ROTATION if self.rotation_submatrix_orthogonal? && !rotation_submatrix_identity?
+      @type |= TRANSLATION unless self.translation_vector.zero?
+      @type |= SCALING unless self.scale_vector.unitity?
+
+      raise ArgumentError, "Transformation is non-linear" unless self.rotation_submatrix_orthogonal? or self.rotation_submatrix_diagonal
+    end
+
+    def type_description
+      names = ["Type #{@type}"]
+      names << 'Translation' if self.translation?
+      names << 'Rotation' if self.rotation?
+      names << 'Scaling' if self.scaling?
+      names.join(' ')
+    end
+
+    def rotation_submatrix
+      @matrix.minor(0..2,0..2)
+    end
+
+    def rotation_submatrix_orthogonal?
+      self.rotation_submatrix.transpose == self.rotation_submatrix.inverse
+    end
+
+    def rotation_submatrix_diagonal?
+      @matrix[1,0] == 0.0 && @matrix[2,0] == 0.0 && @matrix[2,1] == 0.0 &&
+      @matrix[0,1] == 0.0 && @matrix[0,2] == 0.0 && @matrix[1,2] == 0.0 &&
+      @matrix[0,0].abs > TOLERANCE && @matrix[1,1].abs > TOLERANCE && @matrix[2,2].abs > TOLERANCE
+    end
+
+    def identity?
+      @matrix == Matrix.identity(4) * 1.0
+    end
+
+    def rotation_submatrix_identity?
+      self.rotation_submatrix == Matrix.identity(3) * 1.0
+    end
+
+    def scaling?
+      SCALING & self.type > 0.0
+    end
+
+    def translation?
+      TRANSLATION & self.type > 0.0
+    end
+
+    def rotation?
+      ROTATION & self.type > 0.0
+    end
+
+    def scale_vector
+      Vector.new(
+        Math.sqrt(@matrix[0,0]*@matrix[0,0] + @matrix[0,1]*@matrix[0,1] + @matrix[0,2]*@matrix[0,2]),
+        Math.sqrt(@matrix[1,0]*@matrix[1,0] + @matrix[1,1]*@matrix[1,1] + @matrix[1,2]*@matrix[1,2]),
+        Math.sqrt(@matrix[2,0]*@matrix[2,0] + @matrix[2,1]*@matrix[2,1] + @matrix[2,2]*@matrix[2,2])
+        )
+    end
+
+    def to_s(verbose=false)
+      unless verbose
+        "Transformation #{@matrix.to_s}"
+      else
+        str = "Transformation\n"
+        str += "    Vx    |     Vy    |     Vz    |      T\n"
+        str += sprintf("%9.2e | %9.2e | %9.2e | %9.2e\n", @matrix[0,0], @matrix[0,1], @matrix[0,2], @matrix[0,3])
+        str += sprintf("%9.2e | %9.2e | %9.2e | %9.2e\n", @matrix[1,0], @matrix[1,1], @matrix[1,2], @matrix[1,3])
+        str += sprintf("%9.2e | %9.2e | %9.2e | %9.2e\n", @matrix[2,0], @matrix[2,1], @matrix[2,2], @matrix[2,3])
+        str += sprintf("%9.2e | %9.2e | %9.2e | %9.2e",   @matrix[3,0], @matrix[3,1], @matrix[3,2], @matrix[3,3])
+        str
+      end
+    end
+  end
+end