fml 0.2.1

data/lib/floorplanner/design.rb

@@ -0,0 +1,108 @@
+module Floorplanner
+  class Design
+    DESIGN_QUERY   = "/design"
+    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)
+      begin
+        @xml = fml
+        @name   = @xml.find(NAME_QUERY).first.content
+        @author = "John Doe" # TODO from <author> element if included in FML
+      rescue NoMethodError
+        Log.error "Can't load FML"
+      end
+    end
+
+    ##
+    # Builds geometries of walls and areas.
+    ##
+    def build_geometries
+      @areas = AreaBuilder.new do |b|
+        @xml.find(AREAS_QUERY).each do |area|
+          name  = area.find('name').first
+          name  = name.content if name
+          color = area.find('color').first
+          color = color.content if color
+          type  = area.find('type').first.content
+
+          asset_id = area.find('asset').first
+          asset_id = asset_id.attributes['refid'] if asset_id
+          if asset_id
+            texture_url = @xml.find(ASSET_URL2D % [asset_id]).first.content
+          end
+
+          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).each do |line|
+          floats = line.find('points').first.get_floats
+
+          thickness = line.find('thickness').first
+          thickness = thickness ? thickness.content.to_f : Floorplanner.config['wall_thickness']
+          height = line.find('height').first
+          height = height ? height.content.to_f : Floorplanner.config['wall_height']
+
+          # 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).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 % [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,68 @@
+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::Schema.document(
+        XML::Document.file(File.join(File.dirname(__FILE__), "..", "..", "xml", "fml-permissive.xsd"))
+      )
+      doc = XML::Document.file(doc) if doc.instance_of?(String)
+      doc.validate_schema(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 = LibXML::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

data/lib/floorplanner/rib_export.rb

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

data/lib/floorplanner/svg_export.rb

@@ -0,0 +1,25 @@
+module Floorplanner
+  module SvgExport
+    def to_svg
+      # translate to x:0,y:0
+      bbox = @walls.bounding_box
+      dx = bbox[:min].distance_x(bbox[:max])
+      dy = bbox[:min].distance_y(bbox[:max])
+      min_x = -bbox[:min].x
+      min_y = -bbox[:min].y
+      # fit into document dimensions
+      width , height , padding = Floorplanner.config['svg']['width'],
+                                 Floorplanner.config['svg']['height'],
+                                 Floorplanner.config['svg']['padding']
+      ratio = ( width < height ? width : height ) * padding / ( dx > dy ? dx : dy )
+      # center on stage
+      mod_x = min_x + (width /ratio)/2 - dx/2
+      mod_y = min_y + (height/ratio)/2 - dy/2
+
+      template = ERB.new(
+        File.read(
+          File.join(Floorplanner.config['views_path'],'design.svg.erb')))
+      template.result(binding)
+    end
+  end
+end

data/lib/floorplanner/wall3d.rb

@@ -0,0 +1,97 @@
+module Floorplanner
+  class Wall3D < Geom::TriangleMesh
+    UP = Geom::Number3D.new(0,0,1)
+    attr_accessor(:baseline,:outline,:inner,:outer,:name)
+    def initialize(baseline,thickness,height,name)
+      super()
+      @baseline  = baseline
+      @thickness = thickness
+      @height    = height
+      @name      = name
+
+      # create inner and outer Edges of wall
+      @inner = @baseline.offset(@thickness/2.0,UP)
+      @outer = @baseline.offset(-@thickness/2.0,UP)
+      @openings = Array.new
+    end
+
+    def opening(position,size,type)
+      @openings << {:position => position, :size => size, :type => type}
+    end
+
+    def windows
+      @openings.collect{|o| o.window}.compact
+    end
+
+    # create base 'outline' polygon of wall
+    def prepare(num_start_connections,num_end_connections)
+      @outline = Geom::Polygon.new
+      if num_start_connections == 1 || num_start_connections == 2
+        @outline.vertices.push(
+          @outer.start_point,
+          @inner.start_point)
+      else
+        @outline.vertices.push(
+          @outer.start_point,
+          @baseline.start_point,
+          @inner.start_point)
+      end
+
+      if num_end_connections == 1 || num_end_connections == 2
+        @outline.vertices.push(
+          @inner.end_point,
+          @outer.end_point)
+      else
+        @outline.vertices.push(
+          @inner.end_point,
+          @baseline.end_point,
+          @outer.end_point)
+      end
+      @outline.vertices.reverse!
+      @outline.data[:color] = "#ff9999"
+    end
+
+    def update
+      @openings.each_with_index do |opening,i|
+        op = Opening3D.new(@baseline,@thickness,opening)
+        op.update
+        @meshes << op
+        @openings[i] = op
+      end
+      @openings = @openings.sort_by{|o| o.position.distance(@baseline.start_point.position)}
+      @outline.update
+      @meshes << @outline
+
+      # create top cap for wall
+      top_cap = @outline.clone
+      top_cap.transform_vertices(Geom::Matrix3D.translation(0,0,@height))
+      @meshes << top_cap
+      # flip bottom cap
+      @outline.reverse
+
+      # create walls side polygons
+      num    = @outline.vertices.length
+      starts = [@outer.start_point,@inner.start_point,@baseline.start_point]
+      ends   = [@outer.end_point,  @inner.end_point,  @baseline.end_point]
+      outs   = [@outer.start_point,@outer.end_point]
+      @outline.vertices.each_with_index do |v,i|
+        j = @outline.vertices[(i+1) % num]
+        # omit starting and ending polygons
+        next if ( starts.include?(v) && starts.include?(j) ) ||
+                ( ends.include?(v) && ends.include?(j) )
+
+        edge = Geom::Edge.new(v,j)
+        poly = edge.extrude(@height,UP)
+        mesh = Geom::TriangleMesh.new
+        mesh << poly
+
+        # drill holes to side
+        @openings.each do |opening|
+          opening.drill(mesh,outs.include?(v))
+        end
+        mesh.update
+        @meshes << mesh
+      end
+    end
+  end
+end

data/lib/floorplanner/wall_builder.rb

@@ -0,0 +1,165 @@
+module Floorplanner
+  class WallBuilder < Geom::TriangleMesh
+
+    def initialize(&block)
+      super()
+      @connections = Hash.new
+      @base_vertices = Array.new
+      @walls = Array.new
+      block.call(self)
+    end
+
+    def each(&block)
+      @walls.each{|w| block.call(w)}
+    end
+
+    def collect(&block)
+      @walls.collect{|w| block.call(w)}
+    end
+
+    def vertex(vertex)
+      if existing = find_vertex(@base_vertices,vertex,Floorplanner.config['geom_snap'])
+        existing
+      else
+        @base_vertices << vertex
+        vertex
+      end
+    end
+
+    def wall(sp,ep,thickness,height)
+      @connections[sp] = Array.new unless @connections.include?(sp)
+      @connections[ep] = Array.new unless @connections.include?(ep)
+      cs = Geom::Connection.new(ep, 0.0)
+      ce = Geom::Connection.new(sp, 0.0)
+      @connections[sp] << cs unless @connections[sp].include?(cs)
+      @connections[ep] << ce unless @connections[ep].include?(ce)
+      @walls << Wall3D.new(Geom::Edge.new(sp,ep), thickness, height, "wall_#{@walls.length}")
+    end
+
+    # call after adding walls
+    def opening(position,size,type)
+      @walls.each do |wall|
+        if wall.outline.point_inside(position)
+          wall.opening(position,size,type)
+        end
+      end
+    end
+
+    def prepare
+      @base_vertices.each do |v|
+        connections = @connections[v]
+        next if connections.length.zero?
+
+        connections.each do |c|
+          x = c.point.x - v.x
+          y = c.point.y - v.y
+          c.angle = Math.atan2(y,x)
+        end
+        connections.sort! {|a,b| a.angle <=> b.angle}
+        connections.each_index do |i|
+          j = (i+1) % connections.length
+
+          w0 , w1 = find_wall(v,connections[i].point),
+                    find_wall(v,connections[j].point)
+
+          flipped0 , flipped1 = (w0.baseline.end_point == v),
+                                (w1.baseline.end_point == v)
+
+          e0 , e1 = flipped0 ? w0.outer : w0.inner,
+                    flipped1 ? w1.inner : w1.outer
+
+          isect = Geom::Intersection.line_line(e0.start_point.position,e0.end_point.position,e1.start_point.position,e1.end_point.position,true)
+
+          if isect.status == Geom::Intersection::INTERSECTION
+            # the two edges intersect!
+            # adjust the edges so they touch at the intersection.
+            if isect.alpha[0].abs < 2
+              if flipped0
+                e0.end_point.x   = isect.points[0].x
+                e0.end_point.y   = isect.points[0].y
+              else
+                e0.start_point.x = isect.points[0].x
+                e0.start_point.y = isect.points[0].y
+              end
+
+              if flipped1
+                e1.end_point.x   = isect.points[0].x
+                e1.end_point.y   = isect.points[0].y
+              else
+                e1.start_point.x = isect.points[0].x
+                e1.start_point.y = isect.points[0].y
+              end
+            else
+              # parallel
+            end
+          end
+        end
+      end
+
+      @walls.each do |wall|
+        num_start = @connections[wall.baseline.start_point].length
+        num_end   = @connections[wall.baseline.end_point].length
+        wall.prepare(num_start,num_end)
+      end
+    end
+
+    def update
+      @walls.each do |wall|
+        # here comes the cache
+        wall.update
+        @vertices.concat(wall.vertices)
+        @faces.concat(wall.faces)
+      end
+
+      Log.info "Walls Vertices before: #{@vertices.length.to_s}"
+      # remove same instances
+      @vertices.uniq!
+      # remove same vertices
+      old = @vertices.dup
+      @vertices = Array.new
+      old.each do |v|
+        @vertices.push(v) unless @vertices.include?(v) # find_vertex(@vertices,v) #
+      end
+      Log.info "Walls Vertices: #{@vertices.length.to_s}"
+      Log.info "Walls Faces   : #{@faces.length.to_s}"
+    end
+
+    # make use of cache
+    def vertices
+      @vertices
+    end
+
+    def faces
+      @faces
+    end
+
+    def windows
+      @walls.collect{|w| w.windows}.flatten
+    end
+
+  private
+
+    def find_wall(sp,ep)
+      @walls.each do |wall|
+        if wall.baseline.start_point.equal?(sp,Floorplanner.config['geom_snap']) &&
+          wall.baseline.end_point.equal?(ep,Floorplanner.config['geom_snap'])
+            return wall
+        elsif wall.baseline.end_point.equal?(sp,Floorplanner.config['geom_snap']) &&
+          wall.baseline.start_point.equal?(ep,Floorplanner.config['geom_snap'])
+            return wall
+        end
+      end
+      nil
+    end
+
+    def find_vertex(arr,v,snap=Floorplanner.config['uniq_snap'])
+      arr.each do |vertex|
+        if v.equal?(vertex,snap)
+          return vertex
+        end
+      end
+      nil
+    end
+
+  end
+end

data/lib/floorplanner.rb

@@ -0,0 +1,52 @@
+require 'erb'
+require 'yaml'
+require 'find'
+require 'open-uri'
+require 'net/http'
+require 'fileutils'
+require 'logger'
+
+require 'rubygems'
+require 'zip/zip'
+require 'xml'
+
+$LOAD_PATH.push(File.dirname(__FILE__))
+
+module Floorplanner
+
+  Log = Logger.new STDOUT
+  Log.level = Logger::WARN
+  Log.datetime_format = "%Y-%m-%d %H:%M:%S "
+
+  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'