public static Polygon3D ToSAM(this PolyLoop polyLoop, double tolerance = Tolerance.Distance)
{
if (polyLoop == null)
{
return(null);
}
CartesianPoint[] cartesianPoints = polyLoop.Points;
if (cartesianPoints == null || cartesianPoints.Length < 3)
{
return(null);
}
List <Point3D> point3Ds = new List <Point3D>();
foreach (CartesianPoint cartesianPoint in cartesianPoints)
{
Point3D point3D = cartesianPoint.ToSAM(tolerance);
if (point3D == null)
{
return(null);
}
point3Ds.Add(point3D);
}
return(new Polygon3D(point3Ds, tolerance));
}
//receives a polyloop and a list of vector memory safe coordinates
//the polyloop is returned filled with cartesian points
//can only create a polyloop with 100 coordinates at the most
static public PolyLoop MakePolyLoops(PolyLoop pg, List <Vector.MemorySafe_CartCoord> pointslist)
{
pg.Points = new CartesianPoint[pointslist.Count()];
//culturally invariant by default
int listcount = 0;
foreach (Vector.MemorySafe_CartCoord point in pointslist)
{
//we assume that each set ofpoints has three coordinate
//the first is an x coordinate, second is y, third is z
//there will only be three doubles
CartesianPoint pt = new CartesianPoint();
pt.Coordinate = new string[3];
CultureInfo ci = new CultureInfo(String.Empty);
string xformat = string.Format(ci, "{0:0.000000}", point.X);
string yformat = string.Format(ci, "{0:0.000000}", point.Y);
string zformat = string.Format(ci, "{0:0.000000}", point.Z);
pt.Coordinate[0] = xformat;
pt.Coordinate[1] = yformat;
pt.Coordinate[2] = zformat;
pg.Points[listcount] = pt;
listcount++;
}
return(pg);
}
public static PolyLoop[] makePolyLoopArray(int size)
{
PolyLoop[] retarr = new PolyLoop[size];
for (int i = 0; i < size; i++)
{
PolyLoop pl = new PolyLoop();
retarr[i] = pl;
}
return(retarr);
}
private static Polygon ConvertPolygon(PolyLoop polyLoop)
{
var polygon = new Polygon();
foreach (var item in polyLoop.Items)
{
polygon.Points.Add(new Point
{
X = (double)item.Items[0].Value,
Y = (double)item.Items[1].Value,
Z = (double)item.Items[2].Value
});
}
return(polygon);
}
public static PolyLoop TogbXML_PolyLoop(this IClosedPlanar3D closedPlanar3D, double tolerance = Core.Tolerance.MicroDistance)
{
if (closedPlanar3D == null)
{
return(null);
}
List <Point3D> point3Ds = null;
IClosedPlanar3D closedPlanar3D_Temp = null;
if (closedPlanar3D is Face3D)
{
closedPlanar3D_Temp = ((Face3D)closedPlanar3D).GetExternalEdge3D();
}
if (closedPlanar3D_Temp == null)
{
closedPlanar3D_Temp = closedPlanar3D;
}
if (closedPlanar3D_Temp is ISegmentable3D)
{
point3Ds = ((ISegmentable3D)closedPlanar3D_Temp).GetPoints();
}
if (point3Ds == null)
{
throw new System.NotImplementedException();
}
if (!Spatial.Query.Clockwise(closedPlanar3D_Temp, null, tolerance))
{
point3Ds.Reverse();
}
//Plane plane = Spatial.Create.Plane(point3Ds, tolerance);
//if (!plane.Normal.SameHalf(closedPlanar3D.GetPlane().Normal))
// point3Ds.Reverse();
PolyLoop polyLoop = new PolyLoop();
polyLoop.Points = point3Ds.ConvertAll(x => x.TogbXML(tolerance)).ToArray();
return(polyLoop);
}
public static PlanarGeometry makegbPlanarGeom(List <List <Vector.MemorySafe_CartCoord> > coordinates)
{
PlanarGeometry pg = new PlanarGeometry();
PolyLoop pl = new PolyLoop();
pg.PolyLoop = pl;
for (int i = 0; i < coordinates.Count(); i++)
{
//the polyloop array of points is defined
pl.Points = new CartesianPoint[coordinates[i].Count()];
for (int j = 0; j < coordinates[i].Count(); j++)
{
//returns a point with three coordinate strings
CartesianPoint cp = makegbCartesianPt(coordinates[i][j]);
//the point is added to the polyloop
pl.Points[j] = cp;
}
}
return(pg);
}
public static ClosedShell TogbXML(this IEnumerable <Panel> panels, double tolerance = Core.Tolerance.MicroDistance)
{
if (panels == null)
{
return(null);
}
List <PolyLoop> polyLoops = new List <PolyLoop>();
foreach (Panel panel in panels)
{
PolyLoop polyLoop = panel?.GetFace3D(false, tolerance)?.TogbXML_PolyLoop(tolerance);
if (polyLoop != null)
{
polyLoops.Add(polyLoop);
}
}
ClosedShell closedShell = new ClosedShell();
closedShell.PolyLoops = polyLoops.ToArray();
return(closedShell);
}
public static List<gbXMLSpaces> getSimpleSpaces(XmlDocument xmldoc, XmlNamespaceManager xmlns)
{
List<gbXMLSpaces> retspaces = new List<gbXMLSpaces>();
try
{
XmlNodeList nodes = xmldoc.SelectNodes("/gbXMLv5:gbXML/gbXMLv5:Campus/gbXMLv5:Building/gbXMLv5:Space", xmlns);
foreach (XmlNode spaceNode in nodes)
{
//initialize a new instance of the class
gbXMLSpaces space = new gbXMLSpaces();
space.spacebounds = new List<SpaceBoundary>();
//get id and space
XmlAttributeCollection spaceAtts = spaceNode.Attributes;
foreach (XmlAttribute at in spaceAtts)
{
if (at.Name == "id")
{
space.id = at.Value;
break;
}
}
if (spaceNode.HasChildNodes)
{
XmlNodeList childNodes = spaceNode.ChildNodes;
foreach (XmlNode node in childNodes)
{
if (node.Name == "PlanarGeometry")
{
space.pg = new PlanarGeometry();
XmlNodeList childnodes = node.ChildNodes;
foreach (XmlNode node2 in childnodes)
{
if (node2.Name == "PolyLoop")
{
space.pg.pl = new PolyLoop();
space.pg.pl.plcoords = new List<Vector.MemorySafe_CartCoord>();
XmlNodeList cartPoints = node2.ChildNodes;
foreach (XmlNode point in cartPoints)
{
if (point.Name == "CartesianPoint")
{
Vector.CartCoord coord = new Vector.CartCoord();
XmlNodeList val = point.ChildNodes;
int pointcount = 1;
foreach (XmlNode cpoint in val)
{
switch (pointcount)
{
case 1:
coord.X = Convert.ToDouble(cpoint.InnerText);
break;
case 2:
coord.Y = Convert.ToDouble(cpoint.InnerText);
break;
case 3:
coord.Z = Convert.ToDouble(cpoint.InnerText);
break;
}
pointcount++;
}
Vector.MemorySafe_CartCoord memsafecoord = Vector.convertToMemorySafeCoord(coord);
space.pg.pl.plcoords.Add(memsafecoord);
}
}
}
}
}
else if (node.Name == "ShellGeometry")
{
space.sg = new ShellGeometry();
XmlAttributeCollection sgAtts = spaceNode.Attributes;
foreach (XmlAttribute at in sgAtts)
{
if (at.Name == "id")
{
space.sg.id = at.Value;
break;
}
}
XmlNodeList childnodes = node.ChildNodes;
foreach (XmlNode sgnode in childnodes)
{
if (sgnode.Name == "ClosedShell")
{
space.sg.cs = new ClosedShell();
space.sg.cs.ploops = new List<PolyLoop>();
foreach (XmlNode pl in sgnode)
{
if (pl.Name == "PolyLoop")
{
PolyLoop sgpl = new PolyLoop();
sgpl.plcoords = new List<Vector.MemorySafe_CartCoord>();
XmlNodeList cartPoints = pl.ChildNodes;
foreach (XmlNode point in cartPoints)
{
if (point.Name == "CartesianPoint")
{
Vector.CartCoord coord = new Vector.CartCoord();
XmlNodeList val = point.ChildNodes;
int pointcount = 1;
foreach (XmlNode cpoint in val)
{
switch (pointcount)
{
case 1:
coord.X = Convert.ToDouble(cpoint.InnerText);
break;
case 2:
coord.Y = Convert.ToDouble(cpoint.InnerText);
break;
case 3:
coord.Z = Convert.ToDouble(cpoint.InnerText);
break;
}
pointcount++;
}
Vector.MemorySafe_CartCoord memsafecoord = Vector.convertToMemorySafeCoord(coord);
sgpl.plcoords.Add(memsafecoord);
}
}
space.sg.cs.ploops.Add(sgpl);
}
}
}
}
}
else if (node.Name == "SpaceBoundary")
{
SpaceBoundary sb = new SpaceBoundary();
XmlAttributeCollection spbatts = node.Attributes;
foreach (XmlAttribute at in spbatts)
{
if (at.Name == "surfaceIdRef")
{
sb.surfaceIdRef = at.Value;
break;
}
}
XmlNodeList sbchilds = node.ChildNodes;
foreach (XmlNode sbpnode in sbchilds)
{
if (sbpnode.Name == "PlanarGeometry")
{
sb.sbplane = new PlanarGeometry();
XmlNodeList pgchilds = sbpnode.ChildNodes;
foreach (XmlNode pgchild in pgchilds)
{
if (pgchild.Name == "PolyLoop")
{
sb.sbplane.pl = new PolyLoop();
sb.sbplane.pl.plcoords = new List<Vector.MemorySafe_CartCoord>();
XmlNodeList cartPoints = pgchild.ChildNodes;
foreach (XmlNode point in cartPoints)
{
if (point.Name == "CartesianPoint")
{
Vector.CartCoord coord = new Vector.CartCoord();
XmlNodeList val = point.ChildNodes;
int pointcount = 1;
foreach (XmlNode cpoint in val)
{
switch (pointcount)
{
case 1:
coord.X = Convert.ToDouble(cpoint.InnerText);
break;
case 2:
coord.Y = Convert.ToDouble(cpoint.InnerText);
break;
case 3:
coord.Z = Convert.ToDouble(cpoint.InnerText);
break;
}
pointcount++;
}
Vector.MemorySafe_CartCoord memsafecoord = Vector.convertToMemorySafeCoord(coord);
sb.sbplane.pl.plcoords.Add(memsafecoord);
}
}
}
}
}
}
//finally, add the thing here
space.spacebounds.Add(sb);
}
}
}
else
{
//throw something
}
retspaces.Add(space);
}
}
catch (Exception e)
{
}
return retspaces;
}
