floorplanner-fml 0.2

data/README

@@ -0,0 +1 @@
+TODO: write some docs

data/bin/fml2dae.rb

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+$: << File.join(File.dirname(__FILE__), "/../lib" )
+require 'floorplanner'
+
+if ARGV.length < 2
+  puts "\n  Usage: fml2dae.rb [-xrefs] design_id|design_name path/to/fml out.dae" 
+else
+  xrefs = false
+  if ARGV[0] == "-xrefs"
+    ARGV.shift
+    xrefs = true
+  end
+  doc = Floorplanner::Document.new(ARGV[1])
+  doc.to_dae(ARGV[0],ARGV[2],xrefs)
+end

data/bin/fml2obj.rb

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+$: << File.join(File.dirname(__FILE__), "/../lib" )
+require 'floorplanner'
+
+if ARGV.length < 2
+  puts "\n  Usage: fml2dae.rb design_id path/to/fml" 
+else
+  doc = Floorplanner::Document.new(ARGV[1])
+  doc.to_obj(ARGV[0],ARGV[2])
+end

data/lib/collada/document.rb

@@ -0,0 +1,101 @@
+require 'cgi'
+
+module Collada
+  class Document < XML::Document
+    XMLNS = "http://www.collada.org/2005/11/COLLADASchema"
+    VERSION = "1.4.1"
+
+    COLLADA = 'COLLADA'
+    ASSET = 'asset'
+    LIBRARY_MATERIALS = 'library_materials'
+    LIBRARY_EFFECTS = 'library_effects'
+    LIBRARY_GEOMETRIES = 'library_geometries'
+    LIBRARY_VISUAL_SCENES = 'library_visual_scenes'
+    SCENE = 'scene'
+    VISUAL_SCENE = 'visual_scene'
+    INSTANCE_VISUAL_SCENE = 'instance_visual_scene'
+
+    attr_accessor :assets_libraries
+
+    def initialize
+      super
+      self.root = XML::Node.new(COLLADA)
+      self.root.namespaces.namespace = XML::Namespace.new(self.root,nil,XMLNS)
+      self.root.attributes['version'] = VERSION
+
+      create_structure
+
+      self.assets_libraries = []
+    end
+
+    def << (node)
+      root << node
+    end
+
+    def place(doc,position,rotation,scale)
+      unless materials_and_effects_included?(doc.name)
+        doc.library_materials.each do |material|
+          library_materials_node << imported(material)
+        end
+        doc.library_effects.each do |effect|
+          library_effects_node << imported(effect)
+        end
+        materials_and_effects_added(doc.name)
+      end
+
+      doc.library_geometries.each do |geometry|
+        library_geometries_node << imported(geometry)
+      end
+      library_visual_scenes_node << imported(doc.library_visual_scenes)
+    end
+
+    private
+      def create_structure
+        self << XML::Node.new(ASSET)
+
+        self << XML::Node.new(LIBRARY_MATERIALS)
+        self << XML::Node.new(LIBRARY_EFFECTS)
+        self << XML::Node.new(LIBRARY_GEOMETRIES)
+        self << (visual_scenes = XML::Node.new(LIBRARY_VISUAL_SCENES))
+        visual_scenes << (visual_scene = XML::Node.new(VISUAL_SCENE))
+        visual_scene['id'] = 'MainScene'
+        visual_scene['name'] = 'MainScene'
+
+        self << (scene = XML::Node.new(SCENE))
+        scene << (scene_node = XML::Node.new(INSTANCE_VISUAL_SCENE))
+        scene_node['url'] = '#MainScene'
+      end
+
+      def library_visual_scenes_node
+        self.find("//#{VISUAL_SCENE}").first
+      end
+
+      def library_geometries_node
+        find_node(LIBRARY_GEOMETRIES)
+      end
+
+      def library_effects_node
+        find_node(LIBRARY_EFFECTS)
+      end
+
+      def library_materials_node
+        find_node(LIBRARY_MATERIALS)
+      end
+
+      def find_node(node_name)
+        self.root.find(node_name).first
+      end
+
+      def materials_and_effects_included?(namespace)
+        assets_libraries.include?(namespace)
+      end
+
+      def materials_and_effects_added(namespace)
+        assets_libraries << namespace
+      end
+
+      def imported(nodes)
+        self.import(nodes)
+      end
+  end
+end

data/lib/collada/geometry.rb

@@ -0,0 +1,110 @@
+module Collada
+  class Geometry < Geom::TriangleMesh
+
+    SCENE_QUERY        = '/COLLADA/scene/instance_visual_scene'
+    VISUAL_SCENE_QUERY = '/COLLADA/library_visual_scenes/visual_scene[@id="%s"]'
+    GEOMETRY_QUERY     = '/COLLADA/library_geometries/geometry[@id="%s"]'
+    NODE_QUERY         = '/COLLADA/library_nodes//node[@id="%s"]'
+
+    def self.doc(xml)
+      result = Geometry.new
+      result.instance_eval do
+        @xml   = xml
+        @cache = {}
+
+        scene_id = xml.find(SCENE_QUERY).first.attributes['url'][1..-1]
+        scene = xml.find(VISUAL_SCENE_QUERY % scene_id).first
+        scene.children.each do |child|
+          eval_node(child) if child.name == "node"
+        end
+      end
+      result
+    end
+
+    private
+
+    def eval_node(node,parent=nil)
+      parent = node.parent unless parent
+      parent_matrix = Geom::Matrix3D.identity
+      if parent.name == "node"
+        if @cache.include?(parent)
+          parent_matrix = @cache[parent]
+        else
+          parent_matrix = get_node_matrix(parent)
+          @cache[parent] = parent_matrix
+        end
+      end
+
+      node_matrix  = get_node_matrix(node,parent_matrix)
+      @cache[node] = node_matrix
+
+      node.children.each do |child|
+        case child.name
+        when "node"
+          eval_node(child,node)
+        when "instance_geometry"
+          load_geometry(child.attributes['url'][1..-1],node_matrix)
+        when "instance_node"
+          eval_node(expand_node(child),node)
+        end
+      end
+    end
+
+    def load_geometry(gid,matrix=nil)
+      geometry = @xml.find(GEOMETRY_QUERY % gid).first
+      mesh = Geom::TriangleMesh.new
+
+      floats = Array.new
+      geometry.find('mesh/triangles').each do |triangles|
+        vertices_id = triangles.find('input[@semantic="VERTEX"]').first.attributes['source'][1..-1]
+        source_id   = geometry.find('mesh/vertices[@id="%s"]/input[@semantic="POSITION"]' % vertices_id).first.attributes['source'][1..-1]
+
+        floats.concat geometry.find('mesh/source[@id="%s"]/float_array' % source_id).first.get_floats
+      end
+
+      (floats.length/3).times do |i|
+        offset = i*3
+        mesh.vertices.push Geom::Vertex.new(floats[offset],floats[offset+1],floats[offset+2])
+      end
+
+      mesh.transform_vertices(matrix) if matrix
+      @meshes << mesh
+    end
+
+    def expand_node(instance)
+      node_id = instance.attributes['url'][1..-1]
+      @xml.find(NODE_QUERY % node_id).first
+    end
+
+    def get_node_matrix(node,source=nil)
+      result = source ? source : Geom::Matrix3D.identity
+      node.children.each do |child|
+        case child.name
+        when "translate"
+          f = child.get_floats
+          t = Geom::Matrix3D.translation(f[0],f[1],f[2])
+          result = result.multiply(t)
+        when "scale"
+          f = child.get_floats
+          t = Geom::Matrix3D.scale(f[0],f[1],f[2])
+          result = result.multiply(t)
+        when "rotate"
+          f = child.get_floats
+          t = Geom::Matrix3D.rotation_matrix(f[0],f[1],f[2],f[3])
+          result = result.multiply(t)
+        when "matrix"
+          f = child.get_floats
+          t = Geom::Matrix3D[
+            [ *f[0..3]   ],
+            [ *f[4..7]   ],
+            [ *f[8..11]  ],
+            [ *f[12..15] ]
+          ]
+          result = result.multiply(t)
+        end
+      end
+      result
+    end
+
+  end
+end

data/lib/config.yml

@@ -0,0 +1,15 @@
+content_base_url: http://cdn.floorplanner.com/assets/
+dae_cache_path: /home/skrat/workspace/floorplanner/fml2dae_cache/
+area_textures_path: /home/skrat/workspace/floorplanner/fml2dae_cache/textures_2d/
+
+geom_snap:  0.1
+uniq_snap:  0.0000005
+openings:
+  window_base:   0.65
+  window_height: 1.6
+  door_height:   2.2
+
+svg:
+  width:   1024
+  height:  1024
+  padding: 0.8

data/lib/floorplanner.rb

@@ -0,0 +1,46 @@
+require 'erb'
+require 'yaml'
+require 'find'
+require 'open-uri'
+require 'net/http'
+require 'fileutils'
+
+require 'rubygems'
+require 'zip/zip'
+require 'xml'
+
+$LOAD_PATH.push(File.dirname(__FILE__))
+
+module Floorplanner
+  def self.config
+    @@config ||= YAML.load_file(File.join(File.dirname(__FILE__),'config.yml'))
+  end
+
+  def self.config=(yaml)
+    @@config = yaml
+  end
+end
+
+module XML
+  class Node
+    def get_floats
+      content.split(/\s/).delete_if {|s| s.empty?}.map! {|f| f.to_f}
+    end
+  end
+end
+
+require 'geom'
+require 'floorplanner/asset'
+require 'floorplanner/document'
+require 'floorplanner/collada_export'
+require 'floorplanner/rib_export'
+require 'floorplanner/obj_export'
+require 'floorplanner/svg_export'
+require 'floorplanner/design'
+require 'floorplanner/wall3d'
+require 'floorplanner/opening3d'
+require 'floorplanner/wall_builder'
+require 'floorplanner/area_builder'
+require 'collada/document'
+require 'collada/geometry'
+require 'keyhole/archive'

data/lib/floorplanner/area_builder.rb

@@ -0,0 +1,42 @@
+module Floorplanner
+  class AreaBuilder < Geom::TriangleMesh
+
+    attr_reader :ceiling_z
+    
+    def initialize(&block)
+      super()
+      @meshes = {}
+      block.call(self)
+    end
+
+    def each(&block)
+      @meshes.each_value{|a| block.call(a)}
+    end
+
+    def vertex(p)
+      if existing = @vertices.index(p)
+        @vertices[existing]
+      else
+        @vertices << p; p
+      end
+    end
+
+    HEX_RE = "(?i:[a-f\\d])"
+    def area(vertices,params=nil)
+      a_id = vertices.hash.abs.to_s + "_" +params[:type]
+      if params[:color] =~ /\A#((?:#{HEX_RE}{2,2}){3,4})\z/
+         params[:color] = [*$1.scan(/.{2,2}/).collect {|value| value.hex / 255.0}]
+      else
+         params[:color] = [1,1,1]
+      end
+      @meshes[a_id] = Geom::Polygon.new(vertices, nil, params.merge({:id => a_id}))
+    end
+
+    def update(ceiling_z)
+      @ceiling_z = ceiling_z
+      @meshes.each do |id,mesh|
+        mesh.update
+      end
+    end
+  end
+end

data/lib/floorplanner/asset.rb

@@ -0,0 +1,185 @@
+module Floorplanner
+  class Asset
+    LIBRARY_GEOMETRIES   = '/COLLADA/library_geometries/geometry'
+    LIBRARY_EFFECTS      = '/COLLADA/library_effects/effect'
+    LIBRARY_MATERIALS    = '/COLLADA/library_materials/material'
+    LIBRARY_NODES        = '/COLLADA/library_nodes/node'
+    LIBRARY_IMAGES       = '/COLLADA/library_images/image'
+    VISUAL_SCENE_QUERY   = '/COLLADA/library_visual_scenes/visual_scene/node'
+    
+    NO_NS_NAME = %w{ param }
+
+    CACHE_PATH = File.join(Floorplanner.config['dae_cache_path'], 'kmz')
+
+    attr_reader :id, :name, :title, :dae_path
+
+    def self.get(asset_id,asset_title,asset_url3d)
+      FileUtils.mkdir_p(CACHE_PATH)
+      asset_url = Floorplanner.config['content_base_url'] + URI.escape(asset_url3d)
+      
+      cached_path = File.join(CACHE_PATH,asset_id)
+      if File.exists?(cached_path)
+        $stderr.puts("Cached asset: %s" % asset_id)
+        @kmz = Keyhole::Archive.new(cached_path)
+        Asset.new(asset_id,asset_title,@kmz)
+      else
+        $stderr.puts("Downloading asset: %s" % asset_url)
+        cached = File.new(cached_path,'w')
+        remote = open(asset_url)
+        cached.write(remote.read)
+        cached.close
+
+        @kmz = Keyhole::Archive.new(cached_path)
+        asset = Asset.new(asset_id,asset_title,@kmz)
+        asset.adjust_paths!
+        asset
+      end
+    end
+
+    def initialize(id,title,kmz)
+      @dae_path = kmz.dae_path(id)
+      @kmz   = kmz
+      @id    = id
+      @title = title
+      @xml   = XML::Document.string(File.read(@dae_path).gsub(/xmlns=".+"/, ''))
+      @name  = File.basename(@dae_path.gsub(/\.|dae/,''))
+      @images_dict = {}
+    end
+
+    def measurement_unit
+    end
+
+    def library_materials
+      return @materials if @materials
+      materials = @xml.find(LIBRARY_MATERIALS)
+      materials.each {|mat| namespace!(mat)}
+      @materials = materials
+    end
+
+    def library_effects
+      return @effects if @effects
+      effects = @xml.find(LIBRARY_EFFECTS)
+      effects.each {|eff| namespace!(eff)}
+      @effects = effects
+    end
+
+    def library_geometries
+      return @geometries if @geometries
+      geometries = @xml.find(LIBRARY_GEOMETRIES)
+      geometries.each{|geo| namespace!(geo)}
+      @geometries = geometries
+    end
+
+    def library_nodes
+      return @nodes if @nodes
+      nodes = @xml.find(LIBRARY_NODES)
+      nodes.each{|nod| namespace!(nod)}
+      @nodes = nodes
+    end
+
+    def library_images
+      return @images if @images
+      images = @xml.find(LIBRARY_IMAGES)
+      images.each{|img| namespace!(img) && update_path!(img)}
+      @images = images
+    end
+
+    def visual_scene_node
+      return @scene_node if @scene_node
+      @scene_node = namespace!(@xml.find(VISUAL_SCENE_QUERY).first)
+    end
+
+    def bounding_box
+      mesh = Collada::Geometry.doc @xml
+      mesh.bounding_box
+    end
+
+    def bounding_box_size
+      box = bounding_box
+      Geom::Number3D.new(
+        box[:max].distance_x(box[:min]),
+        box[:max].distance_y(box[:min]),
+        box[:max].distance_z(box[:min])
+      )
+    end
+
+    def scale_ratio(target_size)
+      bbox_size = bounding_box_size
+      result = Geom::Number3D.new
+
+      result.x = target_size.x / bbox_size.x
+      result.y = target_size.y / bbox_size.y
+      result.z = 0.01 # (result.x + result.y) / 2.0 # TODO: correct Z size in FML
+
+      result
+    end
+
+    def save_textures(root_path)
+      images = @xml.find(LIBRARY_IMAGES)
+      FileUtils.mkdir_p(root_path) unless images.length.zero?
+
+      images.each do |image|
+        relative_to_dae = image.find('init_from').first.content
+        img_path = @kmz.image_path(@id,relative_to_dae)
+        target_path = File.join(root_path,@id)
+        FileUtils.mkdir_p target_path
+
+        target = open(File.join(target_path,File.basename(img_path)),'w')
+        target.write(File.read(img_path))
+        target.close
+        @images_dict[relative_to_dae] = relative_to_dae[3..-1]
+      end
+    end
+
+    def adjust_paths!
+      images = @xml.find(LIBRARY_IMAGES)
+
+      images.each do |image|
+        init_from = image.find('init_from').first
+        img_path = @kmz.image_path(@id,init_from.content,true)
+        init_from.content = img_path
+      end
+      open(@dae_path, 'w') do |f|
+        f.write @xml.to_s
+      end
+    end
+
+    private
+
+    def namespace!(node)
+      node['id'] = "#{@name}_#{node['id']}" if node['id']
+      node['sid'] = "#{@name}_#{node['sid']}" if node['sid'] && node['sid'] != 'COMMON'
+      node['name'] = "#{@name}_#{node['name']}" if node['name'] && !NO_NS_NAME.include?(node.name)
+      node['symbol'] = "#{@name}_#{node['symbol']}" if node['symbol']
+      node['material'] = "#{@name}_#{node['material']}" if node['material']
+
+
+      node['url'] = "##{@name}_#{node['url'].gsub('#','')}" if node['url']
+      node['target'] = "##{@name}_#{node['target'].gsub('#','')}" if node['target']
+      node['source'] = "##{@name}_#{node['source'].gsub('#','')}" if node['source']
+      node['texture'] = "#{@name}_#{node['texture'].gsub('#','')}" if node['texture']
+
+      if node.name == 'surface'
+        n = node.find('init_from').first
+        n.content = "#{@name}_#{n.content}"
+      end
+
+      if node.name == 'sampler2D'
+        n = node.find('source').first
+        n.content = "#{@name}_#{n.content}"
+      end
+
+      node.children.each do |children|
+        namespace!(children)
+      end
+      node
+    end
+
+    # updates image path to export output folder
+    def update_path!(node)
+      init_from_node = node.find('init_from').first
+      relative = init_from_node.content
+      init_from_node.content = @images_dict[relative]
+    end
+  end
+end