floorplanner-fml 0.2

data/lib/floorplanner/collada_export.rb

@@ -0,0 +1,118 @@
+module Floorplanner
+  class Document
+
+    def to_dae(design_id,out_path,xrefs=false)
+      @design = Design.new(@xml,design_id)
+      @design.build_geometries
+      @design.save_textures File.dirname(out_path) unless xrefs
+      dae = File.new(out_path,'w')
+      dae.write @design.to_dae xrefs
+      dae.close
+    end
+
+  end
+
+  module ColladaExport
+    DESIGN_QUERY   = "/project/floors/floor/designs/design[id='%s']"
+    ASSET_QUERY    = DESIGN_QUERY+"/assets/asset[@id='%s']"
+    ASSETS_QUERY   = DESIGN_QUERY+"/assets/asset"
+    OBJECTS_QUERY  = DESIGN_QUERY+"/objects/object"
+
+    def to_dae(xrefs=false)
+      raise "No geometries to export. Call build_geometries first" unless @areas && @walls
+      @assets   = assets 
+      @elements = objects
+
+      # somehow...
+      @walls.reverse
+      @areas.each {|a| a.reverse}
+      @xrefs = xrefs
+
+      template = ERB.new(
+        File.read(
+          File.join(File.dirname(__FILE__), '..', '..', 'views', 'design.dae.erb')))
+      template.result(binding)
+    end
+
+    def assets
+      return @assets if @assets
+      @assets = {}
+      @xml.find(ASSETS_QUERY % @design_id).each do |asset_node|
+        asset_id = asset_node.attributes['id']
+        name  = asset_node.find('name').first.content
+        url3d = asset_node.find('url3d').first
+        next unless url3d
+        url3d = url3d.content
+
+        # TODO: store asset bounding box
+        asset = Floorplanner::Asset.get(asset_id,name,url3d)
+        next unless asset
+        @assets.store(asset_id, asset)
+      end
+      @assets
+    end
+
+    def objects
+      result = []
+      @xml.find(OBJECTS_QUERY % @design_id).each do |object|
+        begin
+          refid = object.find('asset').first.attributes['refid']
+          next unless assets[refid]
+
+          asset    = assets[refid]
+          position = Geom::Number3D.from_str(object.find('points').first.content)
+          # correct Flash axis issues
+          position.y *= -1.0
+
+          # correct Flash rotation issues
+          rotation = unless object.find('rotation').empty?
+            object.find('rotation').first.content
+          else
+            '0 0 0'
+          end
+          rotation = Geom::Number3D.from_str(rotation)
+          rotation.z += 360 if rotation.z < 0
+          rotation.z += 180
+          
+          # find proper scale for object
+          size     = object.find('size').first.content
+          scale    = asset.scale_ratio(Geom::Number3D.from_str(size))
+
+          mirrored = object.find('mirrored').first
+          reflection = Geom::Matrix3D.reflection(Geom::Plane.new(Geom::Number3D.new(0.0,1.0,0.0), Geom::Number3D.new))
+          if mirrored
+            mirror   = Geom::Number3D.from_str(mirrored)
+            if mirror.x != 0 || mirror.y != 0 || mirror.z != 0
+              mirror.x = mirror.x > 0 ? 1 : 0
+              mirror.y = mirror.y > 0 ? 1 : 0
+              mirror.z = mirror.z > 0 ? 1 : 0
+
+              origin = Geom::Number3D.new
+              plane  = Geom::Plane.new(mirror,origin)
+              reflection = Geom::Matrix3D.reflection(plane).multiply reflection
+            end
+          end
+
+          result << {
+            :asset => asset,
+            :position => position,
+            :rotation => rotation,
+            :scale    => scale,
+            :matrix   => reflection
+          }
+        rescue
+          # TODO: handle text
+        end
+      end
+      result
+    end
+
+    def save_textures(root_path)
+      img_path = File.join(root_path,'textures')
+      FileUtils.mkdir_p img_path
+      assets.each_value do |asset|
+        asset.save_textures img_path
+      end
+    end
+  end
+end

data/lib/floorplanner/design.rb

@@ -0,0 +1,107 @@
+module Floorplanner
+  class Design
+    DESIGN_QUERY   = "/project/floors/floor/designs/design[id='%s']"
+    DESIGN_N_QUERY = "/project/floors/floor/designs/design[name='%s']"
+    ASSET_QUERY    = DESIGN_QUERY+"/assets/asset[@id='%s']"
+    ASSET_URL2D    = ASSET_QUERY+"/url2d"
+    LINES_QUERY    = DESIGN_QUERY+"/lines/line"
+    OPENINGS_QUERY = DESIGN_QUERY+"/objects/object[type='opening']"
+    AREAS_QUERY    = DESIGN_QUERY+"/areas/area"
+    NAME_QUERY     = DESIGN_QUERY+"/name"
+
+    include ColladaExport
+    include ObjExport
+    include RibExport
+    include SvgExport
+
+    ##
+    # Constructs new floorplan design from FML
+    ##
+    def initialize(fml,design_id)
+      begin
+        @xml = fml
+        unless fml.find(DESIGN_QUERY % design_id).length.zero?
+          @design_id = design_id
+        else
+          @design_id = fml.find(DESIGN_N_QUERY % design_id).first.find("id").first.content
+        end
+        @name   = @xml.find(NAME_QUERY % @design_id).first.content
+        @author = "John Doe" # TODO from <author> element if included in FML
+      rescue NoMethodError
+        $stderr.puts "Can't find Design with ID or name: %s" % design_id
+      end
+    end
+
+    ##
+    # Builds geometries of walls and areas.
+    ##
+    def build_geometries
+      @areas = AreaBuilder.new do |b|
+        @xml.find(AREAS_QUERY % @design_id).each do |area|
+          name  = area.find('name').first.content
+          color = area.find('color').first.content
+          type  = area.find('type').first.content
+
+          asset_id = area.find('asset').first.attributes['refid']
+          texture_url = @xml.find(ASSET_URL2D % [@design_id,asset_id]).first.content
+
+          vertices = Array.new
+          area.find('points').first.content.split(',').each do |str_v|
+            floats = str_v.strip.split(/\s/).map! {|f| f.to_f}
+
+            # TODO: fix y coords in Flash app
+            floats[1] *= -1.0; floats[4] *= -1.0
+
+            vertices << b.vertex(Geom::Vertex.new(*floats[0..2]))
+            vertices << b.vertex(Geom::Vertex.new(*floats[3..5]))
+          end
+
+          b.area(vertices,
+            :color => color,
+            :name => name,
+            :texture => texture_url,
+            :type => type)
+
+        end
+      end
+      min_height = 10
+      @walls = WallBuilder.new do |b|
+        @xml.find(LINES_QUERY % @design_id).each do |line|
+          floats = line.find('points').first.get_floats
+          
+          thickness = line.find('thickness').first.content.to_f
+          height = line.find('height').first.content.to_f
+
+          # TODO: fix this in Flash app
+          floats[1] *= -1.0; floats[4] *= -1.0
+
+          sp = Geom::Vertex.new(*floats[0..2])
+          ep = Geom::Vertex.new(*floats[3..5])
+          sp = b.vertex(sp)
+          ep = b.vertex(ep)
+          b.wall(sp,ep,thickness,height)
+          min_height = height if height < min_height
+        end
+      end
+      @areas.update min_height
+
+      @walls.prepare
+      @xml.find(OPENINGS_QUERY % @design_id).each do |opening|
+        pos_floats  = opening.find('points').first.get_floats
+
+        # TODO: fix y coord in Flash app
+        pos_floats[1] *= -1
+
+        size_floats = opening.find('size').first.get_floats
+        position = Geom::Number3D.new(*pos_floats)
+        size     = Geom::Number3D.new(*size_floats)
+        
+        asset_id = opening.find('asset').first.attributes['refid']
+        asset    = @xml.find(ASSET_QUERY % [@design_id,asset_id]).first
+        type     = asset.find('url2d').first.content.match(/door/i) ? Opening3D::TYPE_DOOR : Opening3D::TYPE_WINDOW
+        @walls.opening(position,size,type)
+      end
+      @walls.update
+    end
+  end
+end

data/lib/floorplanner/document.rb

@@ -0,0 +1,66 @@
+module Floorplanner
+
+  class Document
+    POINTS_QUERY = "/project/floors/floor/designs/design/area/line/points"
+    LINE_POINTS_REGEXP = /^((\s*[-+]?[0-9]*\.?[0-9]+\s+){5,8}\s*[-+]?[0-9]*\.?[0-9]+\s*?(?:,)?)*$/
+
+    def initialize(fml_fn)
+      @xml = XML::Document.file(fml_fn)
+    end
+
+    def self.validate(doc)
+      schema = XML::RelaxNG.document(
+        XML::Document.file(File.join(File.dirname(__FILE__), "..", "..", "xml", "fml.rng"))
+      )
+      doc = XML::Document.file(doc) if doc.instance_of?(String)
+      doc.validate_relaxng(schema) do |message,error|
+        # TODO throw an exception
+        puts message if error
+      end
+    end
+
+  private
+
+    def self.validate_line_points(doc)
+      doc.find(POINTS_QUERY).each do |points_node|
+        unless LINE_POINTS_REGEXP =~ points_node.children.to_s
+          # TODO throw an exception
+          puts "Elements points inside area's line failed to validate content."
+        end
+      end
+    end
+  end
+
+  class DesignDocument
+    def initialize(fml_fn)
+      @xml = XML::Document.file(fml_fn)
+    end
+
+    def update_heights(new_height)
+      lines = @xml.find("/design/lines/line[type='default_wall' or type='normal_wall' or contains(type,'hedge') or contains(type,'fence')]")
+      lines.each do |line|
+        begin
+          points = line.find("points").first
+          next unless points.content.include? ","
+
+          coords = points.content.strip.split(",")
+          top_coords = coords[1].strip.split(/\s/).map{|c| c.to_f}
+
+          top_coords[2] = new_height
+          top_coords[5] = new_height
+          if top_coords.length > 6
+            top_coords[8] = new_height
+          end
+
+          coords[1] = top_coords.join(" ")
+          points.content = coords.join(",")
+        rescue; end
+      end
+    end
+
+    def save(fn)
+      @xml.save fn
+    end
+  end
+
+end

data/lib/floorplanner/obj_export.rb

@@ -0,0 +1,24 @@
+module Floorplanner
+  class Document
+
+    def to_obj(design_id,out_path)
+      @design = Design.new(@xml,design_id)
+      @design.build_geometries
+      obj = File.new(out_path,'w')
+      obj.write @design.to_obj
+      obj.close
+    end
+
+  end
+
+  module ObjExport
+    def to_obj
+      raise "No geometries to export. Call build_geometries first" unless @areas && @walls
+
+      template = ERB.new(
+        File.read(
+          File.join(Floorplanner.config['views_path'],'design.obj.erb')))
+      template.result(binding)
+    end
+  end
+end

data/lib/floorplanner/opening3d.rb

@@ -0,0 +1,140 @@
+module Floorplanner
+  class Opening3D < Geom::TriangleMesh
+
+    TYPE_DOOR   = 1
+    TYPE_WINDOW = 2
+
+    attr_accessor(:position,:window)
+
+    def initialize(baseline,thickness,opening)
+      super()
+      @position = baseline.snap(opening[:position])
+      @type     = opening[:type]
+      dir = baseline.direction
+      angle  = Math.atan2(dir.y,dir.x)
+      width  = opening[:size].x
+      height = 0
+
+      case @type
+      when TYPE_DOOR
+        @position.z = 0.01
+        height = Floorplanner.config['openings']['door_height']
+      else
+        @position.z = Floorplanner.config['openings']['window_base']
+        height = Floorplanner.config['openings']['window_height']
+      end
+
+      v1 = Geom::Vertex.new(-width/2,0,0)
+      v2 = Geom::Vertex.new( width/2,0,0)
+      o_base = Geom::Edge.new(v1,v2)
+      
+      # create opening side
+      o_inner = o_base.offset(thickness/2.0,Wall3D::UP)
+      o_outer = o_base.offset(-thickness/2.0,Wall3D::UP)
+
+      @base = Geom::Polygon.new([
+        o_inner.end_point, o_inner.start_point,
+        o_outer.start_point  , o_outer.end_point
+      ])
+
+      # rotate in wall's direction
+      @base.transform_vertices(Geom::Matrix3D.rotationZ(angle))
+      # move to position
+      @base.transform_vertices(Geom::Matrix3D.translation(@position.x,@position.y,@position.z))
+
+      extrusion = @base.extrude(height,Wall3D::UP,nil,false)
+
+      # delete sides
+      extrusion.delete_at(0)
+      extrusion.delete_at(1)
+
+      # flip top cap
+      extrusion.last.reverse
+      
+      @meshes << @base
+      @meshes.concat(extrusion)
+
+      # create glass
+      if @type == TYPE_WINDOW
+        g_inner = o_base.offset( 0.02, Wall3D::UP)
+        g_outer = o_base.offset(-0.02, Wall3D::UP)
+
+        glass_base = Geom::Polygon.new([
+          g_inner.end_point, g_inner.start_point,
+          g_outer.start_point  , g_outer.end_point
+        ])
+
+        # rotate in wall's direction
+        glass_base.transform_vertices(Geom::Matrix3D.rotationZ(angle))
+        # move to position
+        glass_base.transform_vertices(Geom::Matrix3D.translation(@position.x,@position.y,@position.z))
+
+        extrusion = glass_base.extrude(height,Wall3D::UP,nil,false)
+
+        # flip base cap
+        glass_base.reverse
+
+        @window = Geom::TriangleMesh.new
+        @window.meshes.concat extrusion
+        @window << glass_base
+        @window.update
+      end
+    end
+
+    # drill hole to sides
+    def drill(mesh,outer)
+      side = outer ? mesh.meshes.first : mesh.meshes.last
+
+      # opening start
+      t1   = @meshes.first.vertices[outer ? 0 : 3].clone
+      t1.z = side.vertices[0].z
+      t1b  = @meshes[3].vertices[outer ? 0 : 3]
+
+      b1   = @meshes.first.vertices[outer ? 0 : 3].clone
+      b1.z = side.vertices[2].z
+      b1t  = @meshes.first.vertices[outer ? 0 : 3]
+
+      # opening end
+      t2   = @meshes.first.vertices[outer ? 1 : 2].clone
+      t2.z = side.vertices[0].z
+      t2b  = @meshes[3].vertices[outer ? 1 : 2]
+
+      b2   = @meshes.first.vertices[outer ? 1 : 2].clone
+      b2.z = side.vertices[2].z
+      b2t  = @meshes.first.vertices[outer ? 1 : 2]
+
+      # old side vertices
+      ot = side.vertices[1]
+      ob = side.vertices[2]
+      side.vertices[1] = outer ? t2 : t1
+      side.vertices[2] = outer ? b2 : b1
+
+      # polygon above opening
+      op_top = Geom::Polygon.new
+      if outer
+        op_top.vertices.push(t2,t1,t1b,t2b)
+      else
+        op_top.vertices.push(t1,t2,t2b,t1b)
+      end
+
+      # polygon below opening
+      op_bot = Geom::Polygon.new
+      if outer
+        op_bot.vertices.push(b2t,b1t,b1,b2)
+      else
+        op_bot.vertices.push(b1t,b2t,b2,b1)
+      end
+
+      rest = Geom::Polygon.new
+      if outer
+        rest.vertices.push(t1,ot,ob,b1)
+      else
+        rest.vertices.push(t2,ot,ob,b2)
+      end
+      
+      mesh.meshes.push(op_top)
+      mesh.meshes.push(op_bot)
+      mesh.meshes.push(rest)
+    end
+  end
+end