fml 0.2.1

data/.gitignore

@@ -0,0 +1,8 @@
+*.swp
+*.fml
+*~
+assets/
+nbproject/
+cache
+.autotest
+*.gem

data/README

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

data/Rakefile

@@ -0,0 +1,3 @@
+Dir["tasks/**/*.rake"].each { |tasks_file| load(tasks_file) }
+
+GithubGem::RakeTasks.new(:gem)

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[0])
+  doc.to_dae(ARGV[1],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/fml.gemspec

@@ -0,0 +1,36 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name    = "fml"
+  s.version = "0.2.1"
+  s.date    = "2009-09-23"
+  
+  s.required_rubygems_version = Gem::Requirement.new(">= 1.3.0") if s.respond_to? :required_rubygems_version=
+  
+  s.authors = ["Dusan Maliarik"]
+  s.description = %q{Floor plan document toolkit}
+  s.email = %q{dusan.maliarik@gmail.com}
+  s.executables = ["fml2dae.rb","fml2obj.rb"]
+  s.files = %w(lib/keyhole/archive.rb lib/floorplanner/opening3d.rb bin/fml2dae.rb xml/fml2kml.xsl xml/fml.rng xml/collada_schema_1_4.xsd lib/floorplanner/design.rb lib/floorplanner/collada_export.rb views/design.dae.erb lib/geom/plane.rb lib/geom.rb lib/floorplanner/area_builder.rb lib/config.yml .gitignore lib/geom/intersection.rb lib/geom/ear_trim.rb lib/geom/connection.rb lib/floorplanner.rb fml.gemspec lib/geom/polygon.rb lib/geom/edge.rb lib/floorplanner/asset.rb views/design.rib.erb lib/geom/matrix3d.rb lib/floorplanner/rib_export.rb lib/floorplanner/obj_export.rb Rakefile README views/design.obj.erb lib/geom/triangle.rb lib/geom/triangle_mesh.rb lib/floorplanner/wall_builder.rb lib/floorplanner/svg_export.rb lib/collada/geometry.rb views/design.svg.erb tasks/github-gem.rake lib/geom/vertex.rb lib/geom/glu_tess.rb lib/floorplanner/wall3d.rb lib/floorplanner/document.rb bin/fml2obj.rb lib/geom/number.rb lib/collada/document.rb)
+  s.homepage = %q{http://floorplanner.com/}
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.1}
+  s.summary = %q{Floorplanner.com FML document toolkit}
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 2
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<libxml-ruby>)
+      s.add_runtime_dependency(%q<rubyzip>)
+    else
+      s.add_dependency(%q<libxml-ruby>)
+      s.add_dependency(%q<rubyzip>)
+    end
+  else
+    s.add_dependency(%q<libxml-ruby>)
+    s.add_dependency(%q<rubyzip>)
+  end
+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,17 @@
+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/
+
+wall_height: 2.2
+wall_thickness: 0.25
+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/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)
+        Log.info "Cached asset: #{asset_id}"
+        @kmz = Keyhole::Archive.new(cached_path)
+        Asset.new(asset_id,asset_title,@kmz)
+      else
+        Log.info "Downloading asset: #{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

data/lib/floorplanner/collada_export.rb

@@ -0,0 +1,118 @@
+module Floorplanner
+  class Document
+
+    def to_dae(out_path,xrefs=false)
+      @design = Design.new(@xml)
+      @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   = "/design"
+    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).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).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