fml 0.2.3 → 0.2.4

data/lib/floorplanner/design.rb

@@ -1,35 +1,14 @@
 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
+    def initialize(doc)
+      @doc = doc
     end
 
     ##
@@ -37,71 +16,58 @@ module Floorplanner
     ##
     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]))
+        @doc.areas.each do |area|
+          if area.asset
+            texture_url = @doc.asset(area.asset).url2d
           end
 
-          b.area(vertices,
-            :color => color,
-            :name => name,
+          b.area(area.vertices,
+            :color   => area.color,
+            :name    => area.name,
             :texture => texture_url,
-            :type => type)
-
+            :type    => area.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
+      heights = Hash.new
+      @walls = WallBuilder.new do |b|
+        @doc.lines.select{|l| l.type == :default_wall}.each do |line|
+          sp = b.vertex(line.vertices[0])
+          ep = b.vertex(line.vertices[1])
+          b.wall(sp, ep, line.thickness, line.height)
+
+          if heights.include?(line.height)
+            heights[line.height] += 1
+          else
+            heights[line.height] = 1
+          end
         end
       end
-      @areas.update min_height
+      # get the most used (common) height accross linears
+      @areas.update(heights.sort{|a,b| a[1]<=>b[1]}.last[0]-0.02)
 
       @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)
+      @doc.openings.each do |opening|
+        asset = @doc.asset(opening.asset)
+        type  = which_opening(opening, asset)
+        @walls.opening(opening.position ,opening.size, type)
       end
       @walls.update
     end
+
+    private
+
+      def which_opening(opening, asset)
+        case opening.type
+        when :door
+          type = Opening3D::TYPE_DOOR
+        when :window
+          type = Opening3D::TYPE_WINDOW
+        else
+          type = asset.url2d.match(/door/i) ? 
+            Opening3D::TYPE_DOOR : Opening3D::TYPE_WINDOW
+        end
+        type
+      end
   end
 end

data/lib/floorplanner/document.rb

@@ -1,59 +1,33 @@
 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 = LibXML::XML::Document.file(fml_fn)
-    end
-
-    def self.validate(doc)
-      schema = LibXML::XML::RelaxNG.document(
-        LibXML::XML::Document.file(File.join(File.dirname(__FILE__), "..", "..", "xml", "fml.rng"))
-      )
-      doc = LibXML::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
+    def initialize fml_fn
+      @xml = Nokogiri::XML.parse(open(fml_fn))
     end
   end
 
   class DesignDocument
-
-    def initialize(fml)
+    def initialize fml
       if fml.kind_of? String # filename
-        @xml = LibXML::XML::Document.file(fml)
-      elsif fml.kind_of? LibXML::XML::Document
+        @xml = Nokogiri::XML.parse(fml)
+      elsif fml.kind_of? Nokogiri::XML::Document
         @xml = fml
       elsif fml.respond_to?(:read) # IO
-        @xml = LibXML::XML::Document.io(fml)
+        @xml = Nokogiri::XML.parse(fml)
       else
         raise ArgumentError.new("values must be one of: filename, IO, LibXML::XML::Document")
       end
     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')]")
+    def update_heights new_height
+      lines = @xml.xpath("/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
+          points = line.xpath("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 = coords[1].strip.split(/\s/).map(&:to_f)
 
           top_coords[2] = new_height
           top_coords[5] = new_height
@@ -67,11 +41,11 @@ module Floorplanner
       end
     end
 
-    def update_thumb_2d_url(thumb_2d_url)
-      if thumb_node = @xml.find_first('/design/thumb-2d-url')
+    def update_thumb_2d_url thumb_2d_url
+      if thumb_node = @xml.xpath('/design/thumb-2d-url').first
         thumb_node.content = thumb_2d_url
-      elsif design_node = @xml.find_first('/design')
-        thumb_node = LibXML::XML::Node.new('thumb-2d-url')
+      elsif design_node = @xml.xpath('/design').first
+        thumb_node = @xml.create_element('thumb-2d-url')
         thumb_node.content = thumb_2d_url
         design_node << thumb_node
       else
@@ -79,8 +53,8 @@ module Floorplanner
       end
     end
 
-    def save(path)
-      @xml.save path
+    def save path
+      @xml.write_to open(path, 'w')
     end
 
     def to_xml
@@ -91,5 +65,4 @@ module Floorplanner
       @xml.to_s
     end
   end
-
 end

data/lib/floorplanner/opening3d.rb

@@ -8,20 +8,21 @@ module Floorplanner
 
     def initialize(baseline,thickness,opening)
       super()
+      base_z    = opening[:position].z
       @position = baseline.snap(opening[:position])
       @type     = opening[:type]
+      @size     = opening[:size]
       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']
+        height = @size.z == 0 ? Floorplanner.config['openings']['door_height'] : @size.z
       else
-        @position.z = Floorplanner.config['openings']['window_base']
-        height = Floorplanner.config['openings']['window_height']
+        @position.z = base_z == 0 ? Floorplanner.config['openings']['window_base'] : base_z
+        height = @size.z == 0 ? Floorplanner.config['openings']['window_height'] : @size.z
       end
 
       v1 = Geom::Vertex.new(-width/2,0,0)

data/lib/floorplanner/wall_builder.rb

@@ -26,7 +26,7 @@ module Floorplanner
       end
     end
 
-    def wall(sp,ep,thickness,height)
+    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)
@@ -37,10 +37,11 @@ module Floorplanner
     end
 
     # call after adding walls
-    def opening(position,size,type)
+    def opening(position, size, type)
       @walls.each do |wall|
         if wall.outline.point_inside(position)
           wall.opening(position,size,type)
+          break
         end
       end
     end
@@ -51,9 +52,9 @@ module Floorplanner
         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)
+          begin
+            c.angle = Math.atan2(c.point.x - v.x, c.point.y - v.y)
+          rescue; end
         end
         connections.sort! {|a,b| a.angle <=> b.angle}
         connections.each_index do |i|

data/lib/floorplanner/xml.rb

@@ -0,0 +1,151 @@
+module Floorplanner::XML
+
+  class Asset
+    include ROXML
+
+    xml_accessor :id, :from => :attr
+    xml_accessor :name
+    xml_accessor :url2d_str, :from => 'url2d'
+    xml_accessor :url3d
+
+    def url2d
+      url2d_str.match(/swf$/) ? url2d_str.gsub(/swf$/, 'png') : url2d_str
+    end
+  end
+
+  class Line
+    include ROXML
+
+    DEFAULT_HEIGHT = 2.4
+
+    xml_accessor :points
+    xml_accessor :type_str, :from => 'type'
+    xml_accessor :asset, :from => 'asset/@refid'
+    xml_accessor :thickness_str, :from => 'thickness'
+    xml_accessor :height_str, :from => 'height'
+
+    def type
+      type_str.to_sym
+    end
+
+    def height
+      height_str ? height_str.to_f : (
+        vertices[3] ? vertices[3].z : DEFAULT_HEIGHT)
+    end
+
+    def thickness
+      thickness_str.to_f
+    end
+    
+    def vertices
+      @vertices ||= Floorplanner::XML.parse_points(points)
+    end
+  end
+
+  class Area
+    include ROXML
+
+    xml_accessor :points
+    xml_accessor :color
+    xml_accessor :name
+    xml_accessor :asset, :from => 'asset/@refid'
+    xml_accessor :type_str, :from => 'type'
+
+    def type
+      type_str.to_sym if type_str
+    end
+
+    def vertices
+      @vertices ||= Floorplanner::XML.parse_points(points)
+    end
+  end
+
+  class Item
+    include ROXML
+
+    xml_accessor :asset, :from => 'asset/@refid'
+    xml_accessor :type_str, :from => 'type'
+    xml_accessor :color
+
+    xml_accessor :points
+    xml_accessor :size_str, :from => 'size'
+    xml_accessor :rotation_str, :from => 'rotation'
+    xml_accessor :mirrored_str, :from => 'mirrored'
+
+    def type
+      type_str.to_sym
+    end
+
+    def size
+      @scale ||= Floorplanner::XML.parse_vector(size_str)
+    end
+
+    def position
+      @position ||= Floorplanner::XML.parse_point(points)
+    end
+
+    def rotation
+      @rotation ||= Floorplanner::XML.parse_rotation(rotation_str)
+    end
+
+    def mirrored
+      @mirrored ||= Floorplanner::XML.parse_vector(mirrored_str)
+    end
+  end
+
+  class Document
+    include ROXML
+
+    xml_accessor :name
+    xml_accessor :assets,   :as => [Asset]
+    xml_accessor :lines,    :as => [Line]
+    xml_accessor :areas,    :as => [Area]
+    xml_accessor :objects,  :as => [Item]
+    xml_accessor :openings, :as => [Item], 
+      :from => "objects/object[(type='opening') or (type='window') or (type='door')]"
+
+    def asset(refid)
+      assets.detect { |a| a.id == refid }
+    end
+  end
+
+  protected
+
+    # We are inverting Y coordinate here because of Flash
+    # inverted coordinate system
+
+    def self.parse_point(val)
+      f = val.split(/\s/).map{ |s| s.to_f }
+      Geom::Vertex.new(f[0], -f[1], f[2])
+    rescue
+      nil
+    end
+
+    # Inverting Z rotation (Flash again)
+
+    def self.parse_rotation(val)
+      f = val.split(/\s/).map{ |s| s.to_f }
+      Geom::Vertex.new(f[0], f[1], -f[2])
+    rescue
+      nil
+    end
+
+    def self.parse_vector(val)
+      Geom::Vertex.new(*val.split(/\s/).map{ |s| s.to_f })
+    rescue
+      nil
+    end
+
+    def self.parse_points(val)
+      points = val.split(/\s|,/)
+      raise "Invalid coords. count for points" unless points.length % 3 == 0
+
+      result = []
+      points.each_with_index do |x,i|
+        result << [] if i % 3 == 0
+        result.last << x.to_f
+      end
+      result.map { |f| Geom::Vertex.new(f[0], -f[1], f[2]) }
+    end
+end
+

data/lib/floorplanner.rb

@@ -7,7 +7,8 @@ require 'fileutils'
 
 require 'rubygems'
 require 'zip/zip'
-require 'xml'
+require 'nokogiri'
+require 'roxml'
 
 $LOAD_PATH.push(File.dirname(__FILE__))
 
@@ -16,25 +17,26 @@ module Floorplanner
     @@config ||= YAML.load_file(File.join(File.dirname(__FILE__),'config.yml'))
   end
 
-  def self.config=(yaml)
+  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}
+  HEX_RE = "(?i:[a-f\\d])"
+
+  def self.read_color hexstring
+    if hexstring =~ /\A#((?:#{HEX_RE}{2,2}){3,4})\z/
+       return [*$1.scan(/.{2,2}/).collect {|value| value.hex / 255.0}]
+    else
+       return [1,1,1]
     end
   end
 end
 
 require 'geom'
+require 'floorplanner/xml'
 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'

data/lib/geom/edge.rb

@@ -22,7 +22,7 @@ module Geom
       edge = clone
       dir  = direction
 
-      Matrix3D.multiply_vector_3x3(Matrix3D.rotation_matrix(up.x,up.y,up.z, -Math::PI/2),dir)
+      Matrix3D.multiply_vector_3x3(Matrix3D.rotation(up.x,up.y,up.z, -Math::PI/2),dir)
       dir.normalize
 
       dir.x *= distance

data/lib/geom/matrix3d.rb

@@ -9,7 +9,7 @@ module Geom
       ]
     end
 
-    def self.rotation_matrix(x,y,z,rad)
+    def self.rotation(x,y,z,rad)
       n_cos = Math.cos(rad)
       n_sin = Math.sin(rad)
       s_cos = 1 - n_cos
@@ -111,6 +111,10 @@ module Geom
       v.z = vx * ma[2][0] + vy * ma[2][1] + vz * ma[2][2]
     end
 
+    def *(other)
+      multiply(other)
+    end
+
     def multiply(other)
       # matrix multiplication is m[r][c] = (row[r]).(col[c])
       s = to_a
@@ -133,7 +137,8 @@ module Geom
       Matrix3D[
         [rm00, rm01, rm02, rm03],
         [rm10, rm11, rm12, rm13],
-        [rm20, rm21, rm22, rm23]
+        [rm20, rm21, rm22, rm23],
+        [   0,    0,    0,    1]
       ]
     end
 

data/lib/geom/number.rb

@@ -72,6 +72,14 @@ module Geom
       )
     end
 
+    def hash
+      "#{@x}#{@y}#{@z}".hash
+    end
+
+    def eql?(other)
+      self == other
+    end
+
     def == (other)
       @x == other.x &&
       @y == other.y &&

data/lib/geom/polygon.rb

@@ -124,30 +124,26 @@ module Geom
     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
+      x = pt.x;
+      y = pt.y;
+      c = false;
+      length = @vertices.length
+      
+      length.times do |i|
+        j = (i+1) % length
+
+        a = @vertices[i]
+        b = @vertices[j]
+
+        xpi = a.x
+        ypi = a.y
+        xpj = b.x
+        ypj = b.y
+        if ((((ypi<=y) && (y<ypj)) || ((ypj<=y) && (y<ypi))) && (x < (xpj-xpi)*(y-ypi)/(ypj-ypi)+xpi))
+          c = !c
         end
       end
-      result
+      return c;      
     end
 
     def winding

data/lib/geom/vertex.rb

@@ -12,6 +12,14 @@ module Geom
       @normal = normal
     end
 
+    def hash
+      @position.hash
+    end
+
+    def eql?(other)
+      self == other
+    end
+
     def == (other)
       @position == other.position
     end