floorplanner-fml 0.2

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
+
+      $stderr.puts "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
+      $stderr.puts "Walls Vertices: #{@vertices.length.to_s}"
+      $stderr.puts "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/geom.rb

@@ -0,0 +1,13 @@
+$LOAD_PATH.push(File.dirname(__FILE__))
+require 'matrix'
+require 'geom/number'
+require 'geom/vertex'
+require 'geom/triangle_mesh'
+require 'geom/polygon'
+require 'geom/triangle'
+require 'geom/plane'
+require 'geom/matrix3d'
+require 'geom/intersection'
+require 'geom/connection'
+require 'geom/edge'
+require 'geom/ear_trim'

data/lib/geom/connection.rb

@@ -0,0 +1,14 @@
+module Geom
+  class Connection
+    alias_method(:==, :equal?)
+    attr_accessor(:point,:angle)
+    def initialize(point,angle)
+      @point = point
+      @angle = angle
+    end
+
+    def equal?(other)
+      other.point == @point && other.angle == @angle
+    end
+  end
+end

data/lib/geom/ear_trim.rb

@@ -0,0 +1,52 @@
+# 
+# Implements "Ear trimming" triangulation algorithm
+#
+module Geom
+  class EarTrim
+    def self.triangulate(poly)
+      result  = Array.new
+      points  = poly.vertices.dup
+      num     = points.length
+      count   = num*2
+      indices = Hash.new
+
+      return [ [0,1,2] ] if num == 3
+      points.reverse! if poly.winding == Polygon::WINDING_CW
+      points.each_with_index do |p,i|
+        indices[p] = i
+      end
+
+      while num > 2
+        return nil if count > num*2 # overflow
+        count += 1
+
+        i = 0
+        while i < num 
+          j = (i+num-1) % num
+          k = (i+1) % num
+
+          if is_ear(points,j,i,k)
+            # save triangle
+            result.push([indices[points[j]],indices[points[i]],indices[points[k]]])
+            # remove vertex
+            points.delete_at(i)
+            num = points.length
+            count = 0
+          end
+          i += 1
+        end
+      end
+      result
+    end
+
+    def self.is_ear(points,u,v,w)
+      poly = Polygon.new([points[u],points[v],points[w]])
+      return false if poly.area < 0
+      points.length.times do |i|
+        next if i == u || i == v || i == w
+        return false if poly.point_inside(points[i])
+      end
+      true
+    end
+  end
+end

data/lib/geom/edge.rb

@@ -0,0 +1,89 @@
+module Geom
+  class Edge
+    attr_accessor(:start_point,:end_point)
+    def initialize(sp,ep)
+      @start_point = sp
+      @end_point = ep
+    end
+
+    def direction
+      Number3D.sub(@start_point.position,@end_point.position)
+    end
+
+    def length
+      x = @end_point.x - @start_point.x;
+      y = @end_point.y - @start_point.y;
+      z = @end_point.z - @start_point.z;
+      Math.sqrt(x*x + y*y + z*z);
+    end
+
+    def offset(distance,up)
+      up.normalize
+      edge = clone
+      dir  = direction
+
+      Matrix3D.multiply_vector_3x3(Matrix3D.rotation_matrix(up.x,up.y,up.z, -Math::PI/2),dir)
+      dir.normalize
+
+      dir.x *= distance
+      dir.y *= distance
+      dir.z *= distance
+
+      edge.start_point.x += dir.x
+      edge.start_point.y += dir.y
+      edge.start_point.z += dir.z
+      edge.end_point.x += dir.x
+      edge.end_point.y += dir.y
+      edge.end_point.z += dir.z
+
+      edge
+    end
+
+    def extrude(distance,direction)
+      edge = clone
+      [edge.start_point,edge.end_point].each do |v|
+        v.x += distance*direction.x
+        v.y += distance*direction.y
+        v.z += distance*direction.z
+      end
+
+      poly = Polygon.new
+      poly.vertices.push(
+        edge.end_point , edge.start_point,
+        @start_point   , @end_point)
+      poly
+    end
+
+    def snap(point)
+      x1 = @start_point.x
+      y1 = @start_point.y
+      z1 = @start_point.z
+      x2 = @end_point.x
+      y2 = @end_point.y
+      z2 = @end_point.z
+      x3 = point.x
+      y3 = point.y
+      z3 = point.z
+      dx = x2-x1
+      dy = y2-y1
+      dz = z2-z1
+      if dx == 0 && dy == 0 && dz == 0
+        return @start_point
+      else
+        t = ((x3 - x1) * dx + (y3 - y1) * dy + (z3 - z1) * dz) / (dx**2 + dy**2 + dz**2)
+        x0 = x1 + t * dx
+        y0 = y1 + t * dy
+        z0 = z1 + t * dz
+        return Vertex.new(x0,y0,z0)
+      end
+    end
+
+    def clone
+      Edge.new(@start_point.clone,@end_point.clone)
+    end
+
+    def to_s
+      "#<Geom::Edge:#{@start_point.to_s},#{@end_point.to_s}>"
+    end
+  end
+end