fml 0.2.1

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

data/lib/geom/triangle.rb

@@ -0,0 +1,38 @@
+module Geom
+  class Triangle
+
+    attr_accessor :vertices, :texcoord, :normal
+
+    def initialize(vertices,texcoord=nil,normal=nil)
+      unless vertices.length == 3
+        raise "Triangle must consist of exactly 3 vertices"
+      end
+      @normal   = normal || Number3D.new
+      @vertices = vertices
+      @texcoord = texcoord
+      create_normal
+    end
+
+    def flip_normal
+      @normal.x = -@normal.x
+      @normal.y = -@normal.y
+      @normal.z = -@normal.z
+    end
+
+    def clone
+      Triangle.new(@vertices.collect{|v| v.clone},@texcoord.collect{|uv| uv.clone})
+    end
+
+    private
+      def create_normal
+        vn0 = @vertices[0].position.clone
+        vn1 = @vertices[1].position.clone
+        vn2 = @vertices[2].position.clone
+        vn1.minus_eq(vn0)
+        vn2.minus_eq(vn0)
+        @normal = Number3D.cross(vn1,vn2,@normal)
+        @normal.normalize
+      end
+
+  end
+end

data/lib/geom/triangle_mesh.rb

@@ -0,0 +1,94 @@
+module Geom
+  class TriangleMesh
+
+    attr_accessor(:vertices,:texcoord,:faces,:meshes,:data,:tess)
+
+    def initialize( vertices=nil, faces=nil, user_data=nil )
+      @data     = user_data || Hash.new
+      @faces    = faces     || Array.new
+      @vertices = vertices  || Array.new
+      @meshes   = Array.new
+
+      @tess     = EarTrim
+    end
+
+    def << (mesh)
+      @meshes << mesh
+    end
+
+    def vertices
+      result = @meshes.collect {|m| m.vertices}.flatten
+      result.empty? ? @vertices : result
+    end
+
+    def faces
+      result = @meshes.collect {|m| m.faces}.flatten
+      result.empty? ? @faces : result
+    end
+
+    def texcoord
+      result = @meshes.collect {|m| m.texcoord}.flatten
+      result.empty? ? @texcoord : result
+    end
+
+    def update
+      @meshes.each {|m| m.update}
+    end
+
+    def reverse
+      faces.each {|f| f.vertices.reverse! }
+    end
+
+    def transform_vertices(transformation)
+      ta = transformation.to_a
+      m11 = ta[0][0]
+      m12 = ta[0][1]
+      m13 = ta[0][2]
+      m21 = ta[1][0]
+      m22 = ta[1][1]
+      m23 = ta[1][2]
+      m31 = ta[2][0]
+      m32 = ta[2][1]
+      m33 = ta[2][2]
+
+      m14 = ta[0][3]
+      m24 = ta[1][3]
+      m34 = ta[2][3]
+
+      @vertices.each do |v|
+        vx = v.x
+        vy = v.y
+        vz = v.z
+
+        tx = vx * m11 + vy * m12 + vz * m13 + m14
+        ty = vx * m21 + vy * m22 + vz * m23 + m24
+        tz = vx * m31 + vy * m32 + vz * m33 + m34
+
+        v.x = tx
+        v.y = ty
+        v.z = tz
+      end
+    end
+
+    def bounding_box
+      min = Geom::Number3D.new( 1000, 1000, 1000)
+      max = Geom::Number3D.new(-1000,-1000,-1000)
+
+      vertices.each do |v|
+        min.x = v.x if v.x < min.x
+        min.y = v.y if v.y < min.y
+        min.z = v.z if v.z < min.z
+
+        max.x = v.x if v.x > max.x
+        max.y = v.y if v.y > max.y
+        max.z = v.z if v.z > max.z
+      end
+
+      { :max => max , :min => min }
+    end
+
+    def merge(other)
+      @vertices.concat other.vertices
+    end
+  end
+end

data/lib/geom/vertex.rb

@@ -0,0 +1,33 @@
+require 'forwardable'
+
+module Geom
+  class Vertex
+    attr_accessor(:position,:normal)
+    extend Forwardable
+    def_delegators(:@position,
+      :x, :y, :z, :x=, :y=, :z=,
+      :distance_x, :distance_y, :distance_z, :distance, :to_floats)
+    def initialize(x=0.0,y=0.0,z=0.0,normal=nil)
+      @position = Number3D.new(x,y,z)
+      @normal = normal
+    end
+
+    def == (other)
+      @position == other.position
+    end
+
+    def equal?(other,snap)
+      @position.x-snap < other.x && @position.x+snap > other.x &&
+      @position.y-snap < other.y && @position.y+snap > other.y &&
+      @position.z-snap < other.z && @position.z+snap > other.z
+    end
+
+    def clone
+      Vertex.new(x,y,z)
+    end
+
+    def to_s
+      "#<Geom::Vertex:#{@position.to_s}>"
+    end
+  end
+end

data/lib/geom.rb

@@ -0,0 +1,13 @@
+$LOAD_PATH.push(File.dirname(__FILE__))
+require 'matrix'
+require 'geom/number'
+require 'geom/vertex'
+require 'geom/triangle_mesh'
+require 'geom/polygon'
+require 'geom/triangle'
+require 'geom/plane'
+require 'geom/matrix3d'
+require 'geom/intersection'
+require 'geom/connection'
+require 'geom/edge'
+require 'geom/ear_trim'

data/lib/keyhole/archive.rb

@@ -0,0 +1,36 @@
+module Keyhole
+  class Archive < Zip::ZipFile
+    DAE_CACHE_PATH = File.join(Floorplanner.config['dae_cache_path'],'dae')
+    IMG_CACHE_PATH = File.join(Floorplanner.config['dae_cache_path'],'textures')
+
+    def dae_path(asset_id)
+      FileUtils.mkdir_p DAE_CACHE_PATH
+      dae = entries.select{|e| e.name.match(/\.dae$/)}.first
+      @relative_dae_path = dae.name
+      @dae_path = File.join(
+        DAE_CACHE_PATH,
+        "#{asset_id}_#{File.basename(dae.name)}"
+      )
+      dae.extract(@dae_path) unless File.exists?(@dae_path)
+      @dae_path
+    end
+
+    def image_path(asset_id,relative_to_dae,relative_out=false)
+      FileUtils.mkdir_p IMG_CACHE_PATH
+      img_path = File.join(File.dirname(@relative_dae_path),relative_to_dae)
+      target_path = File.join(IMG_CACHE_PATH,asset_id)
+      tex_path = File.join(target_path,File.basename(img_path))
+
+      unless File.exists?(tex_path)
+        FileUtils.mkdir_p target_path
+        zip_image = entries.select{|e| e.name.match(File.basename(img_path)) }.first
+        extract( zip_image , tex_path )
+      end
+      relative_out ? '../textures'+tex_path.gsub(IMG_CACHE_PATH,'') : tex_path
+    end
+
+    def destroy
+      File.unlink(@dae_path)
+    end
+  end
+end