Thread: [Openautomation-svn] SF.net SVN: openautomation:[593] JSFloorPlan/trunk/src/jsfloorplan.js

SourceForge Headquarters 1320 Columbia Street Suite 310 San Diego, CA 92101 +1 (858) 422-6466

Revision: 593
          http://openautomation.svn.sourceforge.net/openautomation/?rev=593&view=rev
Author:   mayerch
Date:     2011-12-18 15:59:22 +0000 (Sun, 18 Dec 2011)
Log Message:
-----------
Whitespace (only!) fix

Modified Paths:
--------------
    JSFloorPlan/trunk/src/jsfloorplan.js

Modified: JSFloorPlan/trunk/src/jsfloorplan.js
===================================================================

--- JSFloorPlan/trunk/src/jsfloorplan.js	2011-12-18 15:45:26 UTC (rev 592)
+++ JSFloorPlan/trunk/src/jsfloorplan.js	2011-12-18 15:59:22 UTC (rev 593)
@@ -31,7 +31,7 @@
 {
   /**
    * The JSFLOORPLAN3D global namespace object. If JSFLOORPLAN3D is already
-   * defined, the existing JSFLOORPLAN3D object will not be overwritten so
+   * defined, the existing JSFLOORPLAN4D object will not be overwritten so
    * that defined namespaces are preserved.
    * @class JSFLOORPLAN3D
    * @static
@@ -40,665 +40,661 @@
 }
 
 JSFLOORPLAN3D= function () {
-var JSFloorPlan3D = this;
-// don't change anything below:
-var ELEMENT_NODE = 1;
-
-// calculate the distance between two cartesian 2D points
-function calcLength2D( start, end )
-{
-  return Math.sqrt( (end.x-start.x)*(end.x-start.x) +
-                    (end.y-start.y)*(end.y-start.y) );
-}
-
-// calculate the rotation of a cartesian 2D point around the center
-function rotate2D( angle, point, center )
-{
-  var s = Math.sin( angle );
-  var c = Math.cos( angle );
-  var ret = new Object;
-  ret.x = center.x + c * (point.x-center.x) - s * (point.y-center.y);
-  ret.y = center.y + s * (point.x-center.x) + c * (point.y-center.y);
-  return ret;
-}
-
-// calculate the rotation of a cartesian 2D point around the center
-// but with given sin and cos of the angle
-function rotate2D( s, c, point, center )
-{
-  var ret = new Object;
-  ret.x = center.x + c * (point.x-center.x) - s * (point.y-center.y);
-  ret.y = center.y + s * (point.x-center.x) + c * (point.y-center.y);
-  return ret;
-}
-
-// calculate the translation of a cartesian 2D point
-function translate2D( point, translation )
-{
-  var ret = new Object;
-  ret.x = point.x + translation.x;
-  ret.y = point.y + translation.y;
-  return ret;
-}
-
-// sort two 2D unit(!) vectors clockwise
-function vecSort( a, b )
-{
-  var pseudoangle_a = a.y>=0 ? (1-a.x) : (a.x+3);  
-  var pseudoangle_b = b.y>=0 ? (1-b.x) : (b.x+3);  
-  return pseudoangle_a - pseudoangle_b; 
-}
-
-//function loadFloorplan()
-//{
-//  $.get('floorplan01.xml', parseXMLFloorPlan, 'xml');
-//}
-var floor;
-
-// this array will contain all vertices to show in the svg
-var vertices = Array();
-// infos about the building
-JSFloorPlan3D.buildingProperties = { floor: [], Object3D: new THREE.Object3D() };
-var imageCenter = new Object;
-
-var noFloorplan = true;
-
-//return { parseXMLFloorPlan: function( xmlDoc )
-JSFloorPlan3D.parseXMLFloorPlan = function( xmlDoc )
-{
-  noFloorplan = false;
-
-  var floorCount = -1;
-  var heightOfGround = 0; // the base level of the current floor
+  var JSFloorPlan3D = this;
+  // don't change anything below:
+  var ELEMENT_NODE = 1;
   
-  // basic check if the document seems right
-  // this could be avoided if the XML file would be validated
-  // with a DTD
-  var building;
-  if( 'building' ==  xmlDoc.documentElement.tagName )
-    building = xmlDoc.documentElement;
-  else
-    return alert( "ERROR: Not a valid floor plan! " + 
-      "Expected: 'building', found '" + xmlDoc.documentElement.tagName + "'" );
-
-  // now we are sure to have a sensible file
-  // => iterate over all floors
-  for( var i=0; i < building.childNodes.length; i++ )
+  // calculate the distance between two cartesian 2D points
+  function calcLength2D( start, end )
   {
-    floor = building.childNodes[i];
-    if (floor.nodeType != ELEMENT_NODE) continue;
-
-    if( floor.tagName == 'textures' )
-    {
-      parseTextures( floor );
-      continue;
-    }  
-
-    if( floor.tagName != 'floor' )
-      return alert( "ERROR: Not a valid floor plan! " +
-        "Expected: 'floor', found '" + floor.tagName + "'" );
+    return Math.sqrt( (end.x-start.x)*(end.x-start.x) +
+    (end.y-start.y)*(end.y-start.y) );
+  }
+  
+  // calculate the rotation of a cartesian 2D point around the center
+  function rotate2D( angle, point, center )
+  {
+    var s = Math.sin( angle );
+    var c = Math.cos( angle );
+    var ret = new Object;
+    ret.x = center.x + c * (point.x-center.x) - s * (point.y-center.y);
+    ret.y = center.y + s * (point.x-center.x) + c * (point.y-center.y);
+    return ret;
+  }
+  
+  // calculate the rotation of a cartesian 2D point around the center
+  // but with given sin and cos of the angle
+  function rotate2D( s, c, point, center )
+  {
+    var ret = new Object;
+    ret.x = center.x + c * (point.x-center.x) - s * (point.y-center.y);
+    ret.y = center.y + s * (point.x-center.x) + c * (point.y-center.y);
+    return ret;
+  }
+  
+  // calculate the translation of a cartesian 2D point
+  function translate2D( point, translation )
+  {
+    var ret = new Object;
+    ret.x = point.x + translation.x;
+    ret.y = point.y + translation.y;
+    return ret;
+  }
+  
+  // sort two 2D unit(!) vectors clockwise
+  function vecSort( a, b )
+  {
+    var pseudoangle_a = a.y>=0 ? (1-a.x) : (a.x+3);  
+    var pseudoangle_b = b.y>=0 ? (1-b.x) : (b.x+3);  
+    return pseudoangle_a - pseudoangle_b; 
+  }
+  
+  var floor;
+  
+  // this array will contain all vertices to show in the svg
+  var vertices = Array();
+  // infos about the building
+  JSFloorPlan3D.buildingProperties = { floor: [], Object3D: new THREE.Object3D() };
+  var imageCenter = new Object;
+  
+  var noFloorplan = true;
+  
+  //return { parseXMLFloorPlan: function( xmlDoc )
+  JSFloorPlan3D.parseXMLFloorPlan = function( xmlDoc )
+  {
+    noFloorplan = false;
     
-    floorCount++;
-    JSFloorPlan3D.buildingProperties.floor[floorCount] = {};
+    var floorCount = -1;
+    var heightOfGround = 0; // the base level of the current floor
     
-    var floorName = floor.getAttribute('name');
-    JSFloorPlan3D.buildingProperties.floor[floorCount].name = floorName;
+    // basic check if the document seems right
+    // this could be avoided if the XML file would be validated
+    // with a DTD
+    var building;
+    if( 'building' ==  xmlDoc.documentElement.tagName )
+      building = xmlDoc.documentElement;
+    else
+      return alert( "ERROR: Not a valid floor plan! " + 
+      "Expected: 'building', found '" + xmlDoc.documentElement.tagName + "'" );
     
-    var floorheight = Number( floor.getAttribute('height') );
-    JSFloorPlan3D.buildingProperties.floor[floorCount].height = floorheight;
-    JSFloorPlan3D.buildingProperties.floor[floorCount].heightOfGround = heightOfGround;
-    
-    var floorWallsStart = 0;// floorWalls.length;  <- not defined here yet...
-
-    // iterate over the content of this floor
-    for( var j=0; j < floor.childNodes.length; j++ )
+    // now we are sure to have a sensible file
+    // => iterate over all floors
+    for( var i=0; i < building.childNodes.length; i++ )
     {
-      floorNode = floor.childNodes[j];
-      if (floorNode.nodeType != ELEMENT_NODE) continue;
-
-      switch( floorNode.tagName )
+      floor = building.childNodes[i];
+      if (floor.nodeType != ELEMENT_NODE) continue;
+                  
+      if( floor.tagName == 'textures' )
       {
-        case 'nodes':
-          parseFloorNodes( floorNode, floorheight );
-          break;
-
-        case 'walls':
-          parseFloorWalls( floorNode );
-          break;
-
-        case 'rooms':
-          parseFloorRooms( floorNode, floorCount );
-          break;
-      }
-    }
-
-    // now the content of the floor is stored in easily
-    // accessable objects
-    // => derive the necessary information
-
-    // group all elements on this floor
-    var Object3D = new THREE.Object3D();
-    
-    // add the information to each node to which nodes it's connected to
-    for( var j = floorWallsStart; j < floorWalls.length; j++ )
-    {
-      // note: the ID is shifted by one to avoid an ID of zero
-      // as that wouldn't allow me anymore to distinguish
-      // start and stop
-      floorNodes[ floorWalls[j].start ].neighbour.push(  j+1 );
-      floorNodes[ floorWalls[j].end   ].neighbour.push( -j-1 );
-    }
-    
-    var nodeGroup = new THREE.Object3D(); nodeGroup.name = 'nodeGroup';
-    for( var id in floorNodes )
-    {
-      // calculate the vectors showing to the neighbours
-      var vectors = new Array();
-      var start = floorNodes[id];
+        parseTextures( floor );
+        continue;
+      }  
       
-      // show them on request as spheres
-      var sphere = new THREE.Mesh( new THREE.SphereGeometry(0.1, 4, 4), sphereMaterial);
-      sphere.position = new THREE.Vector3( start.x, start.y, heightOfGround );
-      nodeGroup.add(sphere);    
+      if( floor.tagName != 'floor' )
+        return alert( "ERROR: Not a valid floor plan! " +
+                      "Expected: 'floor', found '" + floor.tagName + "'" );
       
-      for( var j=0; j<floorNodes[id].neighbour.length; j++ )
-      {
-	var vec = new Object;
-        vec.id = floorNodes[id].neighbour[j];
-        var end;
-	if( vec.id < 0 )
-	  end = floorNodes[ floorWalls[ -vec.id-1 ].start ];
-	else
-	  end = floorNodes[ floorWalls[  vec.id-1 ].end   ];
-
-	length = calcLength2D( start, end );
-	vec.x = (end.x - start.x) / length;
-	vec.y = (end.y - start.y) / length;
-        vectors.push( vec );
-      }
-
-      // sort them clockwise
-      vectors.sort( vecSort );
-
-      // calculate the cutting points of the walls at this node id
-      for( var j=0; j<vectors.length; j++ )
-      {
-        var jj = (j+1) % vectors.length;
-	var wj  = Math.abs(vectors[j ].id)-1;
-	var wjj = Math.abs(vectors[jj].id)-1;
-	var dj  = floorWalls[wj ].thickness/2;
-	var djj = floorWalls[wjj].thickness/2;
-        if(  floorWalls[wj ].startOffset && vectors[j ].id > 0 )
-	  dj  +=  floorWalls[wj].startOffset;
-        if(  floorWalls[wj ].endOffset   && vectors[j ].id < 0 )
-	  dj  +=  floorWalls[wj].endOffset;
-        if(  floorWalls[wjj].startOffset && vectors[jj].id > 0 )
-	  djj += -floorWalls[wjj].startOffset;
-        if(  floorWalls[wjj].endOffset   && vectors[jj].id < 0 )
-	  djj += -floorWalls[wjj].endOffset;
-
-	vertex = new Object;
-	vertex.x = vectors[j].x*djj + vectors[jj].x*dj;
-	vertex.y = vectors[j].y*djj + vectors[jj].y*dj;
-	var l = vectors[j].x*vectors[jj].y - vectors[j].y*vectors[jj].x;
-	if( Math.abs( l ) < 1e-5 )
-	{ // the angle between the two vectors is exactly 180°
-	  // i.e. a straight wall...
-	  if( Math.abs( dj - djj ) < 1e-5 )
-	  { // at least the walls have the same thickness...
-	    vertex.x = start.x - vectors[j].y*dj;
-	    vertex.y = start.y + vectors[j].x*dj;
-	  } else {
-	    alert( "ERROR: A straight wall with different thicknesses " +
-                   "is currently not supported!" );
-	    // but we still try our best...
-	    vertex.x = start.x - vectors[j].y*(dj+djj)/2;
-	    vertex.y = start.y + vectors[j].x*(dj+djj)/2;
-	  }
-	} else {
-	  vertex.x = start.x + vertex.x / l;
-	  vertex.y = start.y + vertex.y / l;
-	}
-	
-	if( vectors[j ].id < 0 )
-	  floorWalls[wj ].startVertex.push( vertices.length );
-	else  
-	  floorWalls[wj ].endVertex.push( vertices.length );
-
-	if( 1 == vectors.length )
-	{
-	  var additional = new Object;
-	  additional.x = 2 * start.x - vertex.x;
-	  additional.y = 2 * start.y - vertex.y;
-	  vertices.push( additional );
-	}
-
-	if( vectors[jj].id < 0 )
-	  floorWalls[wjj].startVertex.push( vertices.length );
-	else  
-	  floorWalls[wjj].endVertex.push( vertices.length );
-
-        vertices.push( vertex );
-      }
-    } // end for( var id in floorNodes )
-    Object3D.add( nodeGroup );
-    
-    // show walls
-    var lineGroup = new THREE.Object3D(); lineGroup.name = 'lineGroup';
-    var wallGroup = new THREE.Object3D(); wallGroup.name = 'wallGroup';
-    for( var j = floorWallsStart; j<floorWalls.length; j++ )
-    {
-      var vs = floorNodes[ floorWalls[j].start ];
-      var ve = floorNodes[ floorWalls[j].end   ];
-      var lineGeo = new THREE.Geometry(); 
-      lineGeo.vertices.push( new THREE.Vertex( new THREE.Vector3( vs.x, vs.y, heightOfGround ) ) ); 
-      lineGeo.vertices.push( new THREE.Vertex( new THREE.Vector3( ve.x, ve.y, heightOfGround ) ) ); 
-      lineGroup.add( new THREE.Line( lineGeo, lineMaterial ) );
+      floorCount++;
+      JSFloorPlan3D.buildingProperties.floor[floorCount] = {};
       
-      var s1 = vertices[ floorWalls[j].startVertex[0] ];
-      var e1 = vertices[ floorWalls[j].endVertex  [0] ];
-      var s2 = vertices[ floorWalls[j].startVertex[1] ];
-      var e2 = vertices[ floorWalls[j].endVertex  [1] ];
+      var floorName = floor.getAttribute('name');
+      JSFloorPlan3D.buildingProperties.floor[floorCount].name = floorName;
       
-      // check that the start and end points aren't twisted
-      var v1 = new Object; v1.x = s1.x-s2.x; v1.y = s1.y-s2.y; 
-      var v2 = new Object; v2.x = e1.x-s2.x; v2.y = e1.y-s2.y;
-      var v3 = new Object; v3.x = e1.x-e2.x; v3.y = e1.y-e2.y;
-      if( (v1.x*v2.y - v1.y*v2.x)*(v2.x*v3.y - v2.y*v3.x) > 0 )
+      var floorheight = Number( floor.getAttribute('height') );
+      JSFloorPlan3D.buildingProperties.floor[floorCount].height = floorheight;
+      JSFloorPlan3D.buildingProperties.floor[floorCount].heightOfGround = heightOfGround;
+      
+      var floorWallsStart = 0;// floorWalls.length;  <- not defined here yet...
+      
+      // iterate over the content of this floor
+      for( var j=0; j < floor.childNodes.length; j++ )
       {
-        e1 = vertices  [ floorWalls[j].endVertex[1] ];
-        e2 = vertices  [ floorWalls[j].endVertex[0] ];
+        floorNode = floor.childNodes[j];
+        if (floorNode.nodeType != ELEMENT_NODE) continue;
+        
+        switch( floorNode.tagName )
+        {
+          case 'nodes':
+            parseFloorNodes( floorNode, floorheight );
+            break;
+            
+          case 'walls':
+            parseFloorWalls( floorNode );
+            break;
+            
+          case 'rooms':
+            parseFloorRooms( floorNode, floorCount );
+            break;
+        }
       }
-      var sm = floorNodes[ floorWalls[j].start ];
-      var em = floorNodes[ floorWalls[j].end   ];
-      var sh = floorNodes[ floorWalls[j].start ].z ; 
-      var eh = floorNodes[ floorWalls[j].end   ].z ;
-      var wallSideOrder = (s2.x-s1.x)*(e1.y-s1.y) - (s2.y-s1.y)*(e1.x-s1.x);
-      var geometry = new THREE.Geometry();
       
-      var normal1 = new THREE.Vector3(sm.y-em.y,-sm.x+em.x,0); // fixme? normalize
-      var normal2 = new THREE.Vector3(1,0,0);
+      // now the content of the floor is stored in easily
+      // accessable objects
+      // => derive the necessary information
       
-      var sourrounding = [ new poly2tri.Point(0,0), new poly2tri.Point(0,1), new poly2tri.Point(1,1), new poly2tri.Point(1,0) ];
-      sourrounding[1].startEndMarker = 'start';
-      sourrounding[2].startEndMarker = 'end';
-      var holesToAdd = [];
+      // group all elements on this floor
+      var Object3D = new THREE.Object3D();
       
-      if( floorWalls[j].holes.length )
+      // add the information to each node to which nodes it's connected to
+      for( var j = floorWallsStart; j < floorWalls.length; j++ )
       {
-        var holes = floorWalls[j].holes;
-        for( var h = 0; h < holes.length; h++ )
+        // note: the ID is shifted by one to avoid an ID of zero
+        // as that wouldn't allow me anymore to distinguish
+        // start and stop
+        floorNodes[ floorWalls[j].start ].neighbour.push(  j+1 );
+        floorNodes[ floorWalls[j].end   ].neighbour.push( -j-1 );
+      }
+      
+      var nodeGroup = new THREE.Object3D(); nodeGroup.name = 'nodeGroup';
+      for( var id in floorNodes )
+      {
+        // calculate the vectors showing to the neighbours
+        var vectors = new Array();
+        var start = floorNodes[id];
+        
+        // show them on request as spheres
+        var sphere = new THREE.Mesh( new THREE.SphereGeometry(0.1, 4, 4), sphereMaterial);
+        sphere.position = new THREE.Vector3( start.x, start.y, heightOfGround );
+        nodeGroup.add(sphere);    
+        
+        for( var j=0; j<floorNodes[id].neighbour.length; j++ )
         {
-          var wallLength = calcLength2D( sm, em );
-          var fLeft  =  holes[h].distance                   / wallLength;
-          var fRight = (holes[h].distance + holes[h].width) / wallLength;
-          if( fLeft  <= 0.0 ) fLeft  = 0.001; //// FIXME - actually the config file is bad. Leave at least 1mm wall
-          if( fRight >= 1.0 ) fRight = 0.999; //// FIXME - actually the config file is bad. Leave at least 1mm wall
-          var lintel  = (sh - holes[h].lintel) / sh;
-          var paparet = holes[h].paparet / sh;
-          if( 1 == lintel )
-          {
-            // not a hole, the sourrounding goes to the groud...
-            
-            if( paparet == 0 ) continue; // FIXME: Assume paparet != 0 - otherwise it should be two walls...
-
-            sourrounding.splice( -2, 0, new poly2tri.Point(fLeft,1), new poly2tri.Point(fLeft,paparet), new poly2tri.Point(fRight,paparet), new poly2tri.Point(fRight,1) );
-            continue;
+          var vec = new Object;
+          vec.id = floorNodes[id].neighbour[j];
+          var end;
+          if( vec.id < 0 )
+            end = floorNodes[ floorWalls[ -vec.id-1 ].start ];
+          else
+            end = floorNodes[ floorWalls[  vec.id-1 ].end   ];
+          
+          length = calcLength2D( start, end );
+          vec.x = (end.x - start.x) / length;
+          vec.y = (end.y - start.y) / length;
+          vectors.push( vec );
+        }
+        
+        // sort them clockwise
+        vectors.sort( vecSort );
+        
+        // calculate the cutting points of the walls at this node id
+        for( var j=0; j<vectors.length; j++ )
+        {
+          var jj = (j+1) % vectors.length;
+          var wj  = Math.abs(vectors[j ].id)-1;
+          var wjj = Math.abs(vectors[jj].id)-1;
+          var dj  = floorWalls[wj ].thickness/2;
+          var djj = floorWalls[wjj].thickness/2;
+          if(  floorWalls[wj ].startOffset && vectors[j ].id > 0 )
+            dj  +=  floorWalls[wj].startOffset;
+          if(  floorWalls[wj ].endOffset   && vectors[j ].id < 0 )
+            dj  +=  floorWalls[wj].endOffset;
+          if(  floorWalls[wjj].startOffset && vectors[jj].id > 0 )
+            djj += -floorWalls[wjj].startOffset;
+          if(  floorWalls[wjj].endOffset   && vectors[jj].id < 0 )
+            djj += -floorWalls[wjj].endOffset;
+          
+          vertex = new Object;
+          vertex.x = vectors[j].x*djj + vectors[jj].x*dj;
+          vertex.y = vectors[j].y*djj + vectors[jj].y*dj;
+          var l = vectors[j].x*vectors[jj].y - vectors[j].y*vectors[jj].x;
+          if( Math.abs( l ) < 1e-5 )
+          { // the angle between the two vectors is exactly 180°
+          // i.e. a straight wall...
+          if( Math.abs( dj - djj ) < 1e-5 )
+          { // at least the walls have the same thickness...
+          vertex.x = start.x - vectors[j].y*dj;
+          vertex.y = start.y + vectors[j].x*dj;
+          } else {
+            alert( "ERROR: A straight wall with different thicknesses " +
+            "is currently not supported!" );
+            // but we still try our best...
+            vertex.x = start.x - vectors[j].y*(dj+djj)/2;
+            vertex.y = start.y + vectors[j].x*(dj+djj)/2;
           }
-          if( 0 == paparet )
+          } else {
+            vertex.x = start.x + vertex.x / l;
+            vertex.y = start.y + vertex.y / l;
+          }
+          
+          if( vectors[j ].id < 0 )
+            floorWalls[wj ].startVertex.push( vertices.length );
+          else  
+            floorWalls[wj ].endVertex.push( vertices.length );
+          
+          if( 1 == vectors.length )
           {
-            // not a hole, the sourrounding goes to the groud...
-            
-            // lintel == 1 can't happen, it's checked in the if clause above
-
-            sourrounding.splice( 0, 0, new poly2tri.Point(fRight,0), new poly2tri.Point(fRight,lintel), new poly2tri.Point(fLeft,lintel), new poly2tri.Point(fLeft,0) );
-            continue;
+            var additional = new Object;
+            additional.x = 2 * start.x - vertex.x;
+            additional.y = 2 * start.y - vertex.y;
+            vertices.push( additional );
           }
           
-          holesToAdd.push( [new poly2tri.Point(fLeft,paparet), new poly2tri.Point(fRight,paparet), new poly2tri.Point(fRight,lintel), new poly2tri.Point(fLeft,lintel)] );
+          if( vectors[jj].id < 0 )
+            floorWalls[wjj].startVertex.push( vertices.length );
+          else  
+            floorWalls[wjj].endVertex.push( vertices.length );
+          
+          vertices.push( vertex );
         }
-      } // if( floorWalls[j].holes.length )
-      var swctx = new poly2tri.SweepContext( sourrounding.slice(0) ); // pass a copy of sourrounding
-      for( var htA = 0; htA < holesToAdd.length; htA++ )
-        swctx.AddHole( holesToAdd[htA] );
+      } // end for( var id in floorNodes )
+      Object3D.add( nodeGroup );
       
-      // Do the triangulation - FIXME: handle exceptions, don't ignore them...
-      try {
-        poly2tri.sweep.Triangulate(swctx);
-      }catch(err){}
-      
-      // mark all points to make sure that we don't need to double vertices
-      for( var tp = 0; tp < swctx.point_count(); tp++ )
-        swctx.GetPoint( tp ).id = tp;
-      
-      // translate poly2tri triangles to THREE.js faces:
-      var p2tF = [];
-      $.each(swctx.GetTriangles(), function(idx, val) {
-        p2tF.push(new THREE.Face3(val.GetPoint(0).id, val.GetPoint(1).id, val.GetPoint(2).id));
-      });
-      
-      Tvertices = swctx.points_;
-      Tfaces = p2tF;
-      var wall1vertices = [];
-      var wall2vertices = [];
-      var sId, eId;
-      for( var v = 0; v < Tvertices.length; v++ )
+      // show walls
+      var lineGroup = new THREE.Object3D(); lineGroup.name = 'lineGroup';
+      var wallGroup = new THREE.Object3D(); wallGroup.name = 'wallGroup';
+      for( var j = floorWallsStart; j<floorWalls.length; j++ )
       {
-        // project s1, e1 and s2, e2 onto line sm->em
-        var lSquaredInv = 1.0 / ((em.x-sm.x)*(em.x-sm.x) + (em.y-sm.y)*(em.y-sm.y));
-        var s1f = 1-((s1.x-sm.x)*(em.x-sm.x) + (s1.y-sm.y)*(em.y-sm.y))*lSquaredInv;
-        var e1f = 1-((e1.x-sm.x)*(em.x-sm.x) + (e1.y-sm.y)*(em.y-sm.y))*lSquaredInv;
-        var s2f = 1-((s2.x-sm.x)*(em.x-sm.x) + (s2.y-sm.y)*(em.y-sm.y))*lSquaredInv;
-        var e2f = 1-((e2.x-sm.x)*(em.x-sm.x) + (e2.y-sm.y)*(em.y-sm.y))*lSquaredInv;
+        var vs = floorNodes[ floorWalls[j].start ];
+        var ve = floorNodes[ floorWalls[j].end   ];
+        var lineGeo = new THREE.Geometry(); 
+        lineGeo.vertices.push( new THREE.Vertex( new THREE.Vector3( vs.x, vs.y, heightOfGround ) ) ); 
+        lineGeo.vertices.push( new THREE.Vertex( new THREE.Vector3( ve.x, ve.y, heightOfGround ) ) ); 
+        lineGroup.add( new THREE.Line( lineGeo, lineMaterial ) );
         
-        var tv = Tvertices[v];
-        var tvx1 = Math.min( 1.0, Math.max( 0.0, (tv.x - s1f) * (e1f - s1f) ) ); // map between s1 and e1
-        var tvx2 = Math.min( 1.0, Math.max( 0.0, (tv.x - s2f) * (e2f - s2f) ) ); // map between s2 and e2
-        var x1 = s1.x * tvx1 + e1.x * (1 - tvx1);
-        var x2 = s2.x * tvx2 + e2.x * (1 - tvx2);
-        var y1 = s1.y * tvx1 + e1.y * (1 - tvx1);
-        var y2 = s2.y * tvx2 + e2.y * (1 - tvx2);
-        //console.log( sm, em, s1, e1, tvx1, x1, y1, s2, e2, tvx2, x2, y2 );
-        var z = heightOfGround + sh*tv.y;
-        if( wallSideOrder > 0 )
+        var s1 = vertices[ floorWalls[j].startVertex[0] ];
+        var e1 = vertices[ floorWalls[j].endVertex  [0] ];
+        var s2 = vertices[ floorWalls[j].startVertex[1] ];
+        var e2 = vertices[ floorWalls[j].endVertex  [1] ];
+        
+        // check that the start and end points aren't twisted
+        var v1 = new Object; v1.x = s1.x-s2.x; v1.y = s1.y-s2.y; 
+        var v2 = new Object; v2.x = e1.x-s2.x; v2.y = e1.y-s2.y;
+        var v3 = new Object; v3.x = e1.x-e2.x; v3.y = e1.y-e2.y;
+        if( (v1.x*v2.y - v1.y*v2.x)*(v2.x*v3.y - v2.y*v3.x) > 0 )
         {
-          wall1vertices.push(new THREE.Vertex(new THREE.Vector3(x1,y1,z), normal1));
-          wall2vertices.push(new THREE.Vertex(new THREE.Vector3(x2,y2,z), normal1));
-        } else {
-          wall1vertices.push(new THREE.Vertex(new THREE.Vector3(x2,y2,z), normal1));
-          wall2vertices.push(new THREE.Vertex(new THREE.Vector3(x1,y1,z), normal1));
+          e1 = vertices  [ floorWalls[j].endVertex[1] ];
+          e2 = vertices  [ floorWalls[j].endVertex[0] ];
         }
-        if( 'startEndMarker' in tv )
+        var sm = floorNodes[ floorWalls[j].start ];
+        var em = floorNodes[ floorWalls[j].end   ];
+        var sh = floorNodes[ floorWalls[j].start ].z ; 
+        var eh = floorNodes[ floorWalls[j].end   ].z ;
+        var wallSideOrder = (s2.x-s1.x)*(e1.y-s1.y) - (s2.y-s1.y)*(e1.x-s1.x);
+        var geometry = new THREE.Geometry();
+        
+        var normal1 = new THREE.Vector3(sm.y-em.y,-sm.x+em.x,0); // fixme? normalize
+        var normal2 = new THREE.Vector3(1,0,0);
+        
+        var sourrounding = [ new poly2tri.Point(0,0), new poly2tri.Point(0,1), new poly2tri.Point(1,1), new poly2tri.Point(1,0) ];
+        sourrounding[1].startEndMarker = 'start';
+        sourrounding[2].startEndMarker = 'end';
+        var holesToAdd = [];
+        
+        if( floorWalls[j].holes.length )
         {
-          if( 'start' == tv.startEndMarker )
+          var holes = floorWalls[j].holes;
+          for( var h = 0; h < holes.length; h++ )
           {
-            sId = wall1vertices.length - 1;
+            var wallLength = calcLength2D( sm, em );
+            var fLeft  =  holes[h].distance                   / wallLength;
+            var fRight = (holes[h].distance + holes[h].width) / wallLength;
+            if( fLeft  <= 0.0 ) fLeft  = 0.001; //// FIXME - actually the config file is bad. Leave at least 1mm wall
+            if( fRight >= 1.0 ) fRight = 0.999; //// FIXME - actually the config file is bad. Leave at least 1mm wall
+            var lintel  = (sh - holes[h].lintel) / sh;
+            var paparet = holes[h].paparet / sh;
+            if( 1 == lintel )
+            {
+              // not a hole, the sourrounding goes to the groud...
+              
+              if( paparet == 0 ) continue; // FIXME: Assume paparet != 0 - otherwise it should be two walls...
+
+              sourrounding.splice( -2, 0, new poly2tri.Point(fLeft,1), new poly2tri.Point(fLeft,paparet), new poly2tri.Point(fRight,paparet), new poly2tri.Point(fRight,1) );
+              continue;
+            }
+            if( 0 == paparet )
+            {
+              // not a hole, the sourrounding goes to the groud...
+              
+              // lintel == 1 can't happen, it's checked in the if clause above
+              
+              sourrounding.splice( 0, 0, new poly2tri.Point(fRight,0), new poly2tri.Point(fRight,lintel), new poly2tri.Point(fLeft,lintel), new poly2tri.Point(fLeft,0) );
+              continue;
+            }
+            
+            holesToAdd.push( [new poly2tri.Point(fLeft,paparet), new poly2tri.Point(fRight,paparet), new poly2tri.Point(fRight,lintel), new poly2tri.Point(fLeft,lintel)] );
+          }
+        } // if( floorWalls[j].holes.length )
+        var swctx = new poly2tri.SweepContext( sourrounding.slice(0) ); // pass a copy of sourrounding
+        for( var htA = 0; htA < holesToAdd.length; htA++ )
+          swctx.AddHole( holesToAdd[htA] );
+        
+        // Do the triangulation - FIXME: handle exceptions, don't ignore them...
+        try {
+          poly2tri.sweep.Triangulate(swctx);
+        }catch(err){}
+        
+        // mark all points to make sure that we don't need to double vertices
+        for( var tp = 0; tp < swctx.point_count(); tp++ )
+          swctx.GetPoint( tp ).id = tp;
+          
+        // translate poly2tri triangles to THREE.js faces:
+        var p2tF = [];
+        $.each(swctx.GetTriangles(), function(idx, val) {
+          p2tF.push(new THREE.Face3(val.GetPoint(0).id, val.GetPoint(1).id, val.GetPoint(2).id));
+        });
+        
+        Tvertices = swctx.points_;
+        Tfaces = p2tF;
+        var wall1vertices = [];
+        var wall2vertices = [];
+        var sId, eId;
+        for( var v = 0; v < Tvertices.length; v++ )
+        {
+          // project s1, e1 and s2, e2 onto line sm->em
+          var lSquaredInv = 1.0 / ((em.x-sm.x)*(em.x-sm.x) + (em.y-sm.y)*(em.y-sm.y));
+          var s1f = 1-((s1.x-sm.x)*(em.x-sm.x) + (s1.y-sm.y)*(em.y-sm.y))*lSquaredInv;
+          var e1f = 1-((e1.x-sm.x)*(em.x-sm.x) + (e1.y-sm.y)*(em.y-sm.y))*lSquaredInv;
+          var s2f = 1-((s2.x-sm.x)*(em.x-sm.x) + (s2.y-sm.y)*(em.y-sm.y))*lSquaredInv;
+          var e2f = 1-((e2.x-sm.x)*(em.x-sm.x) + (e2.y-sm.y)*(em.y-sm.y))*lSquaredInv;
+          
+          var tv = Tvertices[v];
+          var tvx1 = Math.min( 1.0, Math.max( 0.0, (tv.x - s1f) * (e1f - s1f) ) ); // map between s1 and e1
+          var tvx2 = Math.min( 1.0, Math.max( 0.0, (tv.x - s2f) * (e2f - s2f) ) ); // map between s2 and e2
+          var x1 = s1.x * tvx1 + e1.x * (1 - tvx1);
+          var x2 = s2.x * tvx2 + e2.x * (1 - tvx2);
+          var y1 = s1.y * tvx1 + e1.y * (1 - tvx1);
+          var y2 = s2.y * tvx2 + e2.y * (1 - tvx2);
+          //console.log( sm, em, s1, e1, tvx1, x1, y1, s2, e2, tvx2, x2, y2 );
+          var z = heightOfGround + sh*tv.y;
+          if( wallSideOrder > 0 )
+          {
+            wall1vertices.push(new THREE.Vertex(new THREE.Vector3(x1,y1,z), normal1));
+            wall2vertices.push(new THREE.Vertex(new THREE.Vector3(x2,y2,z), normal1));
           } else {
-            eId = wall1vertices.length - 1;
+            wall1vertices.push(new THREE.Ver...
 
[truncated message content]

Thread: [Openautomation-svn] SF.net SVN: openautomation:[593] JSFloorPlan/trunk/src/jsfloorplan.js

Building automation (like KNX or OpenHAB) software (like CometVisu).

openautomation-svn