floorplanner-fml 0.2

data/lib/geom/intersection.rb

@@ -0,0 +1,38 @@
+module Geom
+  class Intersection
+    INTERSECTION    = 1
+    NO_INTERSECTION = 0
+    attr_accessor(:alpha,:points,:status)
+    def initialize(status=NO_INTERSECTION)
+      @alpha  = Array.new
+      @points = Array.new
+      @status = status
+    end
+
+    def self.line_line(a1,a2,b1,b2,infinite=true)
+      result = Intersection.new
+
+      x1, y1 = a1.x, a1.y
+      x2, y2 = a2.x, a2.y
+      x3, y3 = b1.x, b1.y
+      x4, y4 = b2.x, b2.y
+
+      d = ((y4-y3)*(x2-x1)-(x4-x3)*(y2-y1))
+
+      unless d.zero?
+        # The lines intersect at a point somewhere
+        ua = ((x4-x3)*(y1-y3)-(y4-y3)*(x1-x3)) / d
+        ub = ((x2-x1)*(y1-y3)-(y2-y1)*(x1-x3)) / d
+        
+        result.alpha.push(ua,ub)
+        if infinite || ((ua > 0 && ua < 1) && (ub > 0 && ub < 1))
+          x = x1 + ua*(x2-x1)
+          y = y1 + ua*(y2-y1)
+          result.points << Number3D.new(x,y)
+          result.status = INTERSECTION;
+        end
+      end
+      result
+    end
+  end
+end

data/lib/geom/matrix3d.rb

@@ -0,0 +1,141 @@
+module Geom
+  class Matrix3D < Matrix
+    def self.identity
+      Matrix3D[
+        [1,0,0,0],
+        [0,1,0,0],
+        [0,0,1,0],
+        [0,0,0,1]
+      ]
+    end
+
+    def self.rotation_matrix(x,y,z,rad)
+      n_cos = Math.cos(rad)
+      n_sin = Math.sin(rad)
+      s_cos = 1 - n_cos
+
+      sxy = x * y * s_cos
+      syz = y * z * s_cos
+      sxz = x * z * s_cos
+
+      sz  = n_sin * z
+      sy  = n_sin * y
+      sx  = n_sin * x
+
+      n11  = n_cos + x * x * s_cos
+      n12  = -sz + sxy
+      n13  = sy + sxz
+      n14  = 0
+
+      n21  = sz + sxy
+      n22  = n_cos + y * y * s_cos
+      n23  = -sx + syz
+      n24  = 0
+
+      n31  = -sy + sxz
+      n32  = sx + syz
+      n33  = n_cos + z * z * s_cos
+      n34  = 0
+
+      self[
+        [n11,n12,n13,n14],
+        [n21,n22,n23,n24],
+        [n31,n32,n33,n34],
+        [0,0,0,1]
+      ]
+    end
+
+    def self.rotationX(rad)
+      c = Math.cos(rad)
+      s = Math.sin(rad)
+
+      self[
+        [1,0, 0,0],
+        [0,c,-s,0],
+        [0,s, c,0],
+        [0,0, 0,1],
+      ]
+    end
+
+    def self.rotationZ(rad)
+      c  = Math.cos(rad)
+      s  = Math.sin(rad)
+
+      self[
+        [c,-s,0,0],
+        [s, c,0,0],
+        [0, 0,1,0],
+        [0, 0,0,1]
+      ]
+    end
+
+    def self.translation(x,y,z)
+      self[
+        [1,0,0,x],
+        [0,1,0,y],
+        [0,0,1,z],
+        [0,0,0,1]
+      ]
+    end
+
+    def self.scale(x,y,z)
+      self[
+        [x,0,0,0],
+        [0,y,0,0],
+        [0,0,z,0],
+        [0,0,0,1]
+      ]
+    end
+
+    def self.reflection(plane)
+      a = plane.normal.x
+      b = plane.normal.y
+      c = plane.normal.z
+      
+      self[
+        [1-(2*a*a) , 0-(2*a*b) , 0-(2*a*c) , 0],
+        [0-(2*a*b) , 1-(2*b*b) , 0-(2*b*c) , 0],
+        [0-(2*a*c) , 0-(2*b*c) , 1-(2*c*c) , 0],
+        [0         , 0         , 0         , 1]
+      ]
+    end
+
+    def self.multiply_vector_3x3(m,v)
+      ma = m.to_a
+      vx = v.x
+      vy = v.y
+      vz = v.z
+
+      v.x = vx * ma[0][0] + vy * ma[0][1] + vz * ma[0][2]
+      v.y = vx * ma[1][0] + vy * ma[1][1] + vz * ma[1][2]
+      v.z = vx * ma[2][0] + vy * ma[2][1] + vz * ma[2][2]
+    end
+
+    def multiply(other)
+      # matrix multiplication is m[r][c] = (row[r]).(col[c])
+      s = to_a
+      o = other.to_a
+      rm00 = s[0][0] * o[0][0] + s[0][1] * o[1][0] + s[0][2] * o[2][0]
+      rm01 = s[0][0] * o[0][1] + s[0][1] * o[1][1] + s[0][2] * o[2][1]
+      rm02 = s[0][0] * o[0][2] + s[0][1] * o[1][2] + s[0][2] * o[2][2]
+      rm03 = s[0][0] * o[0][3] + s[0][1] * o[1][3] + s[0][2] * o[2][3] + s[0][3]
+
+      rm10 = s[1][0] * o[0][0] + s[1][1] * o[1][0] + s[1][2] * o[2][0]
+      rm11 = s[1][0] * o[0][1] + s[1][1] * o[1][1] + s[1][2] * o[2][1]
+      rm12 = s[1][0] * o[0][2] + s[1][1] * o[1][2] + s[1][2] * o[2][2]
+      rm13 = s[1][0] * o[0][3] + s[1][1] * o[1][3] + s[1][2] * o[2][3] + s[1][3]
+
+      rm20 = s[2][0] * o[0][0] + s[2][1] * o[1][0] + s[2][2] * o[2][0]
+      rm21 = s[2][0] * o[0][1] + s[2][1] * o[1][1] + s[2][2] * o[2][1]
+      rm22 = s[2][0] * o[0][2] + s[2][1] * o[1][2] + s[2][2] * o[2][2]
+      rm23 = s[2][0] * o[0][3] + s[2][1] * o[1][3] + s[2][2] * o[2][3] + s[2][3]
+
+      Matrix3D[
+        [rm00, rm01, rm02, rm03],
+        [rm10, rm11, rm12, rm13],
+        [rm20, rm21, rm22, rm23]
+      ]
+    end
+
+  end
+end

data/lib/geom/number.rb

@@ -0,0 +1,104 @@
+module Geom
+
+  class Number3D
+
+    attr_accessor(:x,:y,:z)
+
+    def initialize(x=0,y=0,z=0)
+      @x, @y, @z = x, y, z
+    end
+
+    def self.sub(v,w)
+      Number3D.new(
+        v.x - w.x,
+        v.y - w.y,
+        v.z - w.z
+      )
+    end
+
+    def self.cross(v,w,target=nil)
+      target ||= Number3D.new
+      target.reset((w.y * v.z) - (w.z * v.y), (w.z * v.x) - (w.x * v.z), (w.x * v.y) - (w.y * v.x))
+      target
+    end
+
+    def self.dot(v,w)
+      v.x * w.x + v.y * w.y + w.z * v.z
+    end
+
+    def self.from_str(str)
+      x,y,z = str.split(' ') if str
+      str.nil? ? Number3D.new : Number3D.new(x.to_f,y.to_f,z.to_f)
+    end
+
+    def reset(nx=nil,ny=nil,nz=nil)
+      @x = nx if nx
+      @y = ny if ny
+      @z = nz if nz
+    end
+
+    def normalize
+      mod = Math.sqrt( @x**2 + @y**2 + @z**2 )
+      if mod != 0 && mod != 1
+        mod = 1 / mod # mults are cheaper then divs
+        @x *= mod
+        @y *= mod
+        @z *= mod
+      end
+    end
+
+    def minus_eq(v)
+      @x -= v.x
+      @y -= v.y
+      @z -= v.z
+    end
+
+    def distance_x(other)
+      (@x - other.x).abs
+    end
+    
+    def distance_y(other)
+      (@y - other.y).abs
+    end
+    
+    def distance_z(other)
+      (@z - other.z).abs
+    end
+    
+    def distance(other)
+      Math.sqrt(
+        distance_z(other) ** 2 +
+        Math.sqrt(distance_x(other)**2 + distance_y(other)**2) ** 2
+      )
+    end
+    
+    def == (other)
+      @x == other.x &&
+      @y == other.y &&
+      @z == other.z
+    end
+
+    def to_s
+      "#<Geom::Number3D:#{@x},#{@y},#{@z}>"
+    end
+
+    def to_floats
+      [@x,@y,@z].join ' '
+    end
+  end
+
+  class NumberUV
+
+    attr_accessor :u, :v
+    
+    def initialize(u=0,v=0)
+      @u = u
+      @v = v
+    end
+
+    def clone
+      NumberUV.new(u,v)
+    end
+  end
+
+end

data/lib/geom/plane.rb

@@ -0,0 +1,36 @@
+module Geom
+  class Plane
+    attr_accessor(:normal)
+    def initialize(normal=nil,point=nil)
+      if normal && point
+        @normal = normal
+        @d      = -Number3D.dot(normal,point)
+      else
+        @normal = Number3D.new
+        @d      = 0
+      end
+    end
+
+    def self.three_points(p0,p1,p2)
+      plane = Plane.new
+      n0 = p0.instance_of?(Number3D) ? p0 : p0.position
+      n1 = p1.instance_of?(Number3D) ? p1 : p1.position
+      n2 = p2.instance_of?(Number3D) ? p2 : p2.position
+      plane.set_three_points(n0,n1,n2)
+      plane
+    end
+
+    def set_three_points(p0,p1,p2)
+      ab = Number3D.sub(p1,p0)
+      ac = Number3D.sub(p2,p0)
+      @normal = Number3D.cross(ab,ac)
+      @normal.normalize
+      @d = -Number3D.dot(@normal,p0)
+    end
+
+    def distance(point)
+      p = point.instance_of?(Vertex) ? point.position : point
+      Number3D.dot(p,@normal) + @d
+    end
+  end
+end

data/lib/geom/polygon.rb

@@ -0,0 +1,264 @@
+module Geom
+  class Polygon < TriangleMesh
+
+    WINDING_CW   = 0
+    WINDING_CCW  = 1
+
+    AXIS_X       = 1
+    AXIS_Y       = 2
+    AXIS_Z       = 3
+
+    CAP_TOP      = 4
+    CAP_BASE     = 5
+    CAP_BOTH     = 6
+
+    def clone
+      vertices = @vertices.collect{|v| v.clone}
+      texcoord = @texcoord ? @texcoord.collect{|uv| uv.clone} : nil
+      faces    = @faces.collect do |f|
+        if texcoord
+          Triangle.new([
+            vertices[ @vertices.index(f.vertices[0]) ],
+            vertices[ @vertices.index(f.vertices[1]) ],
+            vertices[ @vertices.index(f.vertices[2]) ]
+          ],[
+            texcoord[ @texcoord.index(f.texcoord[0]) ],
+            texcoord[ @texcoord.index(f.texcoord[1]) ],
+            texcoord[ @texcoord.index(f.texcoord[2]) ]
+          ])
+        else
+          Triangle.new([
+            vertices[ @vertices.index(f.vertices[0]) ],
+            vertices[ @vertices.index(f.vertices[1]) ],
+            vertices[ @vertices.index(f.vertices[2]) ]
+          ])
+        end
+      end
+      result = Polygon.new(vertices,faces,@data.dup)
+      result.texcoord = texcoord
+      result
+    end
+
+    def update
+      return false if @vertices.length < 3
+      triangles = @tess.triangulate(self)
+      unless triangles
+        @vertices.reverse!
+        triangles = @tess.triangulate(self)
+        return false unless triangles
+      end
+
+      @texcoord = calc_uv
+      triangles.each do |t|
+        v0 = @vertices[t[0]]
+        v1 = @vertices[t[1]]
+        v2 = @vertices[t[2]]
+
+        t0 = @texcoord[t[0]]
+        t1 = @texcoord[t[1]]
+        t2 = @texcoord[t[2]]
+        @faces.push(Triangle.new([v2,v1,v0],[t0,t1,t2]))
+      end
+      true
+    end
+
+    def area
+      # remove duplicates and invisibles
+      return nil if @vertices.length < 3
+      @vertices.each{|v| return 0 if @vertices.grep(v).length>1}
+
+      result = 0
+      points = @vertices.dup
+      plane  = self.plane
+
+      ax = plane.normal.x > 0 ? plane.normal.x : -plane.normal.x
+      ay = plane.normal.y > 0 ? plane.normal.y : -plane.normal.y
+      az = plane.normal.z > 0 ? plane.normal.z : -plane.normal.z
+
+      coord = AXIS_Z
+
+      if ax > ay
+        if ax > az
+          coord = AXIS_X
+        end
+      elsif ay > az
+        coord = AXIS_Y
+      end
+
+      points.push(points[0],points[1])
+
+      # compute area of the 2D projection
+      points.each_with_index do |point,i|
+        next if i.zero?
+        j = (i+1) % points.length
+        k = (i-1) % points.length
+
+        case coord
+        when AXIS_X
+          result += (point.y * (points[j].z - points[k].z))
+        when AXIS_Y
+          result += (point.x * (points[j].z - points[k].z))
+        else
+          result += (point.x * (points[j].y - points[k].y))
+        end
+      end
+              
+      # scale to get area before projection
+      an = Math.sqrt(ax**2 + ay**2 + az**2) # length of normal vector
+      case coord
+      when AXIS_X
+        result *= (an / (2*ax))
+      when AXIS_Y
+        result *= (an / (2*ay))
+      when AXIS_Z
+        result *= (an / (2*az))
+      end
+      2.times {points.pop}
+      result
+    end
+
+    # TODO real plane, not just from first 3 vertices
+    def plane
+      return nil if @vertices.length < 3
+      Plane.three_points(*@vertices[0..2])
+    end
+
+    def point_inside(pt)
+      x = "x"
+      y = "y"
+      n = @vertices.length
+      dominant = dominant_axis
+      dist = self.plane.distance(pt)
+      result = false
+      
+      return false if dist.abs > 0.01
+      case dominant
+      when AXIS_X
+        x = "y"
+        y = "z"
+      when AXIS_Y
+        y = "z"
+      end
+
+      @vertices.each_with_index do |v,i|
+        vn = @vertices[(i+1)%n] # next
+        if (((v.send(y) <= pt.send(y)) && (pt.send(y) < vn.send(y))) || ((vn.send(y) <= pt.send(y)) && (pt.send(y) < v.send(y)))) &&
+            (pt.send(x) < (vn.send(x) - v.send(x)) * (pt.send(y) - v.send(y)) / (vn.send(y) - v.send(y)) + v.send(x))
+          result = !result
+        end
+      end
+      result
+    end
+
+    def winding
+      area < 0 ? WINDING_CW : WINDING_CCW
+    end
+
+    def extrude(distance,direction,cap=CAP_BOTH,update=true)
+      direction.normalize
+      top_cap = clone
+      top_cap.vertices.each do |v|
+        v.x += distance*direction.x
+        v.y += distance*direction.y
+        v.z += distance*direction.z
+      end
+      top_cap.faces.each {|f| f.normal = direction }
+      num = @vertices.length
+
+      sides = Array.new(@vertices.length).map!{ Polygon.new }
+      sides.each_with_index do |side,i|
+        j = (i+1) % num
+        side.vertices.push(top_cap.vertices[i],top_cap.vertices[j])
+        side.vertices.push(@vertices[j],@vertices[i])
+        side.data[:side] = true
+        side.update if update
+      end
+
+      case cap
+      when CAP_BASE
+        top_cap.faces.clear
+      when CAP_TOP
+        self.faces.clear
+      when CAP_BOTH
+        self.faces.each do |f|
+          f.flip_normal
+        end
+      end
+
+      sides + [top_cap]
+    end
+
+    def dominant_axis
+      plane = self.plane
+      return 0 unless plane
+
+      ax = (plane.normal.x > 0 ? plane.normal.x : -plane.normal.x)
+      ay = (plane.normal.y > 0 ? plane.normal.y : -plane.normal.y)
+      az = (plane.normal.z > 0 ? plane.normal.z : -plane.normal.z)
+
+      axis = AXIS_Z
+      if ax > ay
+        if ax > az
+          axis = AXIS_X
+        end
+      elsif ay > az
+        axis = AXIS_Y
+      end
+      axis
+    end
+
+    def calc_uv
+      result = []
+      plane = self.plane
+      up = Number3D.new( 0, 1, 0 )
+      
+      # get side vector
+      side = Number3D.cross(up, plane.normal)
+      side.normalize
+
+      # adjust up vector
+      up = Number3D.cross(self.plane.normal, side)
+      up.normalize
+      
+      matrix  = Matrix3D[
+              [side.x, up.x, plane.normal.x, 0],
+              [side.y, up.y, plane.normal.y, 0],
+              [side.z, up.z, plane.normal.z, 0],
+              [0, 0, 0, 1]]
+      
+      v, n, t = nil, nil, nil
+      min = Number3D.new(1000,1000,1000)
+      max = Number3D.new(-min.x, -min.y, -min.z)
+      pts = []
+
+      @vertices.each do |v|
+        n = v.position
+        
+        # Matrix3D.multiplyVector3x3( matrix, n );
+        
+        min.x = n.x if n.x < min.x
+        min.y = n.y if n.y < min.y
+        max.x = n.x if n.x > max.x
+        max.y = n.y if n.y > max.y
+        
+        pts << n
+        result << NumberUV.new
+      end
+      
+      w = max.x - min.x
+      h = max.y - min.y
+      size = w < h ? h : w
+      
+      @vertices.each_with_index do |v,i|
+        n = pts[i]
+        t = result[i]
+
+        t.u = ((n.x - min.x) / size) * size
+        t.v = ((n.y - min.y) / size) * size
+      end
+      
+      result
+    end
+
+  end
+end