public XbimShapeGeometry ShapeGeometry(int shapeGeometryLabel)
{
IXbimShapeGeometryData shapeGeometry = new XbimShapeGeometry();
_shapeGeometryCursor.TryGetShapeGeometry(shapeGeometryLabel, ref shapeGeometry);
return((XbimShapeGeometry)shapeGeometry);
}
/***************************************************/
/**** Public Methods ****/
/***************************************************/
public static List <Mesh> Meshes(this XbimShapeInstance instance, Xbim3DModelContext context)
{
if (instance == null)
{
BH.Engine.Reflection.Compute.RecordError("The meshes could not be extracted because the IFC element is null.");
return(null);
}
if (context == null)
{
BH.Engine.Reflection.Compute.RecordError("The meshes could not be extracted because the 3D model context is null.");
return(null);
}
List <Mesh> result;
//Instance's geometry
XbimShapeGeometry geometry = context.ShapeGeometry(instance);
byte[] data = ((IXbimShapeGeometryData)geometry).ShapeData;
//If you want to get all the faces and trinagulation use this
using (var stream = new MemoryStream(data))
{
using (var reader = new BinaryReader(stream))
{
XbimShapeTriangulation shape = reader.ReadShapeTriangulation();
result = shape.Meshes();
}
}
TransformMatrix transform = instance.Transformation.TransformMatrixFromIfc();
return(result.Select(x => x.Transform(transform)).ToList());
}
private void WriteShapeGeometry(JsonWriter writer, XbimShapeGeometry geom, XbimMatrix3D?transform = null)
{
XbimMeshGeometry3D mesh = new XbimMeshGeometry3D();
mesh.Read(geom.ShapeData, transform);
writer.WritePropertyName("positions");
writer.WriteStartArray();
foreach (var point in mesh.Positions)
{
writer.WriteValue(Math.Round(point.X, 4)); //we are converting to metres so this is effectively .1mm
writer.WriteValue(Math.Round(point.Y, 4));
writer.WriteValue(Math.Round(point.Z, 4));
}
writer.WriteEndArray();
writer.WritePropertyName("indices");
writer.WriteStartArray();
foreach (var idx in mesh.TriangleIndices)
{
writer.WriteValue(idx);
}
writer.WriteEndArray();
writer.WritePropertyName("normals");
writer.WriteStartArray();
foreach (var norm in mesh.Normals)
{
writer.WriteValue(norm.X);
writer.WriteValue(norm.Y);
writer.WriteValue(norm.Z);
}
writer.WriteEndArray();
}
internal int AddShapeGeometry(XbimShapeGeometry shapeGeometry)
{
int id = Interlocked.Increment(ref _geometryCount);
shapeGeometry.ShapeLabel = id;
_shapeGeometries.TryAdd(id, shapeGeometry);
return(id);
}
public void IfcStoreGeometryStoreAddTest()
{
using (var model = IfcStore.Open("TestFiles\\SampleHouse4.ifc"))
{
var geomStore = model.GeometryStore;
using (var txn = geomStore.BeginInit())
{
//ADD A GEOMETRY SHAPE
var geomData = new XbimShapeGeometry()
{
IfcShapeLabel = 1,
Format = XbimGeometryType.BoundingBox,
GeometryHash = 0,
LOD = XbimLOD.LOD100,
ReferenceCount = 1,
ShapeData = "2123",
BoundingBox = XbimRect3D.Empty
};
var shapeGeomLabel = txn.AddShapeGeometry(geomData);
//ADD A SHAPE INSTANCE
var shapeInstance = new XbimShapeInstance()
{
ShapeGeometryLabel = shapeGeomLabel,
StyleLabel = 5,
RepresentationContext = 50
};
var instanceId = txn.AddShapeInstance(shapeInstance, shapeGeomLabel);
Assert.IsTrue(instanceId == 1);
//ADD A REGIONCOLLECTION
var regions = new XbimRegionCollection();
regions.ContextLabel = 50;
var bb = new XbimRect3D(new XbimPoint3D(1, 1, 1), new XbimVector3D(10, 20, 30));
regions.Add(new XbimRegion("region1", bb, 100, XbimMatrix3D.Identity));
txn.AddRegions(regions);
txn.Commit();
}
model.SaveAs("SampleHouse4.xbim", StorageType.Xbim);
model.Close();
}
using (var model = IfcStore.Open(@"SampleHouse4.xbim"))
{
var geomStore = model.GeometryStore;
Assert.IsFalse(geomStore.IsEmpty);
using (var reader = geomStore.BeginRead())
{
Assert.IsTrue(reader.ContextIds.Any());
Assert.IsTrue(reader.ContextRegions.First().ContextLabel == 50);
Assert.IsTrue(reader.ShapeGeometries.Count() == 1);
Assert.IsTrue(reader.ShapeInstances.Count() == 1);
Assert.IsTrue(reader.StyleIds.Count == 1);
}
model.Close();
}
}
public void EsentGeometryStoreReopenAddTest()
{
var db = Guid.NewGuid().ToString() + ".xbim";
var ifc = "TestFiles\\4walls1floorSite.ifc";
var p = new EsentModelProvider {
DatabaseFileName = db
};
var s = p.GetXbimSchemaVersion(ifc);
using (var m = p.Open(ifc, s)) { p.Close(m); }
using (var model = IfcStore.Open(db, accessMode: XbimDBAccess.ReadWrite))
{
var geomStore = model.GeometryStore;
using (var txn = geomStore.BeginInit())
{
//ADD A GEOMETRY SHAPE
var geomData = new XbimShapeGeometry()
{
IfcShapeLabel = 1,
Format = XbimGeometryType.BoundingBox,
GeometryHash = 0,
LOD = XbimLOD.LOD100,
ReferenceCount = 1,
ShapeData = "2123",
BoundingBox = XbimRect3D.Empty
};
var shapeGeomLabel = txn.AddShapeGeometry(geomData);
//ADD A SHAPE INSTANCE
var shapeInstance = new XbimShapeInstance()
{
ShapeGeometryLabel = shapeGeomLabel,
StyleLabel = 5,
RepresentationContext = 50
};
var instanceId = txn.AddShapeInstance(shapeInstance, shapeGeomLabel);
Assert.IsTrue(instanceId == 1);
//ADD A REGIONCOLLECTION
var regions = new XbimRegionCollection
{
ContextLabel = 50
};
var bb = new XbimRect3D(new XbimPoint3D(1, 1, 1), new XbimVector3D(10, 20, 30));
regions.Add(new XbimRegion("region1", bb, 100, XbimMatrix3D.Identity));
txn.AddRegions(regions);
txn.Commit();
}
model.SaveAs("SampleHouse4.xbim", StorageType.Xbim);
model.Close();
}
}
public void EsentGeometryStoreMultiThreadTest()
{
using (var model = IfcStore.Create(null, XbimSchemaVersion.Ifc4, XbimStoreType.EsentDatabase))
{
var store = model.GeometryStore;
using (var txn = store.BeginInit())
{
Parallel.For(0, 100, i =>
{
//ADD A GEOMETRY SHAPE
var geomData = new XbimShapeGeometry()
{
IfcShapeLabel = 1,
Format = XbimGeometryType.BoundingBox,
GeometryHash = 0,
LOD = XbimLOD.LOD100,
ReferenceCount = 1,
ShapeData = "2123",
BoundingBox = XbimRect3D.Empty
};
var shapeInstance = new XbimShapeInstance()
{
ShapeGeometryLabel = i + 1
};
var shapeGeomLabel = txn.AddShapeGeometry(geomData);
var instanceId = txn.AddShapeInstance(shapeInstance, shapeGeomLabel);
});
Parallel.For(0, 100, i =>
{
//ADD A SHAPE INSTANCE
var shapeInstance = new XbimShapeInstance()
{
ShapeGeometryLabel = i + 1
};
var instanceId = txn.AddShapeInstance(shapeInstance, i + 1);
});
//ADD A REGIONCOLLECTION
var regions = new XbimRegionCollection {
ContextLabel = 50
};
regions.Add(new XbimRegion("region1", XbimRect3D.Empty, 100, XbimMatrix3D.Identity));
txn.AddRegions(regions);
txn.Commit();
}
model.Close();
}
}
public void Test_PolygonalFaceSet_Tessellation()
{
XbimGeometryType tp = Xbim.Common.Geometry.XbimGeometryType.PolyhedronBinary;
using (var model = IfcStore.Open("TestFiles\\polygonal-face-tessellation.ifc"))
{
var xbimTessellator = new XbimTessellator(model, tp);
XbimShapeGeometry shapeGeom = null;
var shape = model.Instances.FirstOrDefault <IIfcPolygonalFaceSet>();
shapeGeom = xbimTessellator.Mesh(shape);
Assert.AreEqual(8000000000000, shapeGeom.BoundingBox.Volume);
}
}
public void TestPnSize_Add2_Support()
{
XbimGeometryType tp = Xbim.Common.Geometry.XbimGeometryType.PolyhedronBinary;
using (var model = IfcStore.Open("TestFiles\\IfcTriangulatedFaceSet.ifc"))
{
var xbimTessellator = new XbimTessellator(model, tp);
XbimShapeGeometry shapeGeom = null;
var shape = model.Instances[48] as IIfcGeometricRepresentationItem;
shapeGeom = xbimTessellator.Mesh(shape);
Debug.WriteLine(shapeGeom.BoundingBox);
}
}
public void TestBoundingBoxSize()
{
XbimGeometryType tp = Xbim.Common.Geometry.XbimGeometryType.PolyhedronBinary;
using (var model = IfcStore.Open("Roof-01_BCAD.ifc"))
{
var xbimTessellator = new XbimTessellator(model, tp);
XbimShapeGeometry shapeGeom = null;
var shape = model.Instances[1192] as IIfcGeometricRepresentationItem;
shapeGeom = xbimTessellator.Mesh(shape);
Debug.WriteLine(shapeGeom.BoundingBox);
}
}
public static MeshGeometry3D WriteTriangles(IIfcProduct ifcElement, Xbim3DModelContext context, XbimMatrix3D wcsTransformation)
{
MeshBuilder meshBuilder = new MeshBuilder(false, false);
// var allTriangles = new List<Triangles>();
// foreach (XbimShapeInstance instance in context.ShapeInstancesOf(ifcElement).Where(x => x.RepresentationType == XbimGeometryRepresentationType.OpeningsAndAdditionsIncluded))
foreach (XbimShapeInstance instance in context.ShapeInstancesOf(ifcElement).Where(x => x.RepresentationType == XbimGeometryRepresentationType.OpeningsAndAdditionsIncluded))
{
XbimShapeGeometry geometry = context.ShapeGeometry(instance);
var data = ((IXbimShapeGeometryData)geometry).ShapeData;
using (var stream = new MemoryStream(data))
{
using (var reader = new BinaryReader(stream))
{
XbimShapeTriangulation mesh = reader.ReadShapeTriangulation();
mesh = mesh.Transform(instance.Transformation);
// WCS transforms
mesh = mesh.Transform(wcsTransformation);
foreach (XbimFaceTriangulation face in mesh.Faces)
{
var j = 0;
for (var i = 0; i < face.TriangleCount; i++)
{
int k = i + j;
var point1 = new Point3D {
X = mesh.Vertices[face.Indices[k]].X, Y = mesh.Vertices[face.Indices[k]].Y, Z = mesh.Vertices[face.Indices[k]].Z
};
j++;
k = i + j;
var point2 = new Point3D {
X = mesh.Vertices[face.Indices[k]].X, Y = mesh.Vertices[face.Indices[k]].Y, Z = mesh.Vertices[face.Indices[k]].Z
};
j++;
k = i + j;
var point3 = new Point3D {
X = mesh.Vertices[face.Indices[k]].X, Y = mesh.Vertices[face.Indices[k]].Y, Z = mesh.Vertices[face.Indices[k]].Z
};
meshBuilder.AddTriangle(point1, point2, point3);
}
}
}
}
}
return(meshBuilder.ToMesh());
// return allTriangles;
}
public void ResourceReleaseTest()
{
using (var model = IfcStore.Open("TestFiles\\SampleHouse4.ifc", null, 0))
{
using (var txn = model.GeometryStore.BeginInit())
{
//ADD A GEOMETRY SHAPE
var geomData = new XbimShapeGeometry()
{
IfcShapeLabel = 1,
Format = XbimGeometryType.BoundingBox,
GeometryHash = 0,
LOD = XbimLOD.LOD100,
ReferenceCount = 1,
ShapeData = "2123",
BoundingBox = XbimRect3D.Empty
};
var shapeGeomLabel = txn.AddShapeGeometry(geomData);
//ADD A SHAPE INSTANCE
var shapeInstance = new XbimShapeInstance()
{
ShapeGeometryLabel = shapeGeomLabel,
StyleLabel = 5,
RepresentationContext = 50
};
var instanceId = txn.AddShapeInstance(shapeInstance, shapeGeomLabel);
Assert.IsTrue(instanceId == 1);
//ADD A REGIONCOLLECTION
var regions = new XbimRegionCollection();
regions.ContextLabel = 50;
var bb = new XbimRect3D(new XbimPoint3D(1, 1, 1), new XbimVector3D(10, 20, 30));
regions.Add(new XbimRegion("region1", bb, 100, XbimMatrix3D.Identity));
txn.AddRegions(regions);
txn.Commit();
}
int c = model.Instances.OfType <IfcDoor>().Count();
model.Close();
}
Thread.SpinWait(200);
// TODO:: ISSUE HERE... when the whole suite of tests is run then the count could be greater than,
// even if they are reduced correctly
Assert.IsTrue(IO.Esent.EsentModel.ModelOpenCount == 0);
}
public void InMemoryGeometryStoreMultiThreadTest()
{
using (var model = new IO.Memory.MemoryModel(new EntityFactory()))
{
var store = model.GeometryStore;
using (var txn = store.BeginInit())
{
Parallel.For(0, 100, i =>
{
//ADD A GEOMETRY SHAPE
var geomData = new XbimShapeGeometry()
{
IfcShapeLabel = 1,
Format = XbimGeometryType.BoundingBox,
GeometryHash = 0,
LOD = XbimLOD.LOD100,
ReferenceCount = 1,
ShapeData = "2123",
BoundingBox = XbimRect3D.Empty
};
var shapeGeomLabel = txn.AddShapeGeometry(geomData);
});
Parallel.For(0, 100, i =>
{
//ADD A SHAPE INSTANCE
var shapeInstance = new XbimShapeInstance()
{
ShapeGeometryLabel = i + 1
};
var instanceId = txn.AddShapeInstance(shapeInstance, i + 1);
});
//ADD A REGIONCOLLECTION
var regions = new XbimRegionCollection {
ContextLabel = 50
};
regions.Add(new XbimRegion("region1", XbimRect3D.Empty, 100));
txn.AddRegions(regions);
txn.Commit();
}
}
}
// Private fix for bug in Geom.Shape
private IEnumerable <XbimShapeGeometry> GetGeom(XbimModel model)
{
using (var shapeGeometryTable = model.GetShapeGeometryTable())
{
using (shapeGeometryTable.BeginReadOnlyTransaction())
{
IXbimShapeGeometryData shapeGeometry = new XbimShapeGeometry();
if (shapeGeometryTable.TryMoveFirstShapeGeometry(ref shapeGeometry))
{
do
{
yield return((XbimShapeGeometry)shapeGeometry);
shapeGeometry = new XbimShapeGeometry();
} while (shapeGeometryTable.TryMoveNextShapeGeometry(ref shapeGeometry));
}
}
}
}
public int AddShapeGeometry(XbimShapeGeometry shapeGeometry)
{
lock (_shapeGeometryCursor)
{
SetGeometryContext();
try
{
long remainder = _geometryCount % TransactionBatchSize; //pulse transactions
if (remainder == TransactionBatchSize - 1)
{
_shapeGeometryTransaction.Commit();
_shapeGeometryTransaction.Begin();
}
_geometryCount++;
return(_shapeGeometryCursor.AddGeometry(shapeGeometry));
}
finally
{
ResetGeometryContext();
}
}
}
private XbimShapeGeometry MeshPolyhedronText(IEnumerable <IList <IIfcFace> > facesList, int entityLabel, float precision)
{
var shapeGeometry = new XbimShapeGeometry();
shapeGeometry.Format = XbimGeometryType.Polyhedron;
using (var ms = new MemoryStream(0x4000))
using (TextWriter textWriter = new StreamWriter(ms))
{
var faceLists = facesList.ToList();
var triangulations = new List <XbimTriangulatedMesh>(faceLists.Count);
foreach (var faceList in faceLists)
{
triangulations.Add(TriangulateFaces(faceList, entityLabel, precision));
}
// Write out header
uint verticesCount = 0;
uint triangleCount = 0;
uint facesCount = 0;
var boundingBox = XbimRect3D.Empty;
foreach (var triangulatedMesh in triangulations)
{
verticesCount += triangulatedMesh.VertexCount;
triangleCount += triangulatedMesh.TriangleCount;
facesCount += (uint)triangulatedMesh.Faces.Count;
if (boundingBox.IsEmpty)
{
boundingBox = triangulatedMesh.BoundingBox;
}
else
{
boundingBox.Union(triangulatedMesh.BoundingBox);
}
}
textWriter.WriteLine("P {0} {1} {2} {3} {4}", 2, verticesCount, facesCount, triangleCount, 0);
//write out vertices and normals
textWriter.Write("V");
foreach (var p in triangulations.SelectMany(t => t.Vertices))
{
textWriter.Write(" {0},{1},{2}", p.X, p.Y, p.Z);
}
textWriter.WriteLine();
//now write out the faces
uint verticesOffset = 0;
foreach (var triangulatedMesh in triangulations)
{
foreach (var faceGroup in triangulatedMesh.Faces)
{
textWriter.Write("T");
int currentNormal = -1;
foreach (var triangle in faceGroup.Value)
{
var pn1 = triangle[0].PackedNormal.ToUnit16();
var pn2 = triangle[0].NextEdge.PackedNormal.ToUnit16();
var pn3 = triangle[0].NextEdge.NextEdge.PackedNormal.ToUnit16();
if (pn1 != currentNormal)
{
textWriter.Write(" {0}/{1},", triangle[0].StartVertexIndex + verticesOffset, pn1);
currentNormal = pn1;
}
else
{
textWriter.Write(" {0},", triangle[0].StartVertexIndex + verticesOffset);
}
if (pn1 != pn2)
{
textWriter.Write("{0}/{1},", triangle[0].NextEdge.StartVertexIndex + verticesOffset, pn2);
currentNormal = pn2;
}
else
{
textWriter.Write("{0},", triangle[0].NextEdge.StartVertexIndex + verticesOffset);
}
if (pn2 != pn3)
{
textWriter.Write("{0}/{1}", triangle[0].NextEdge.NextEdge.StartVertexIndex + verticesOffset, pn3);
currentNormal = pn3;
}
else
{
textWriter.Write("{0}", triangle[0].NextEdge.NextEdge.StartVertexIndex + verticesOffset);
}
}
textWriter.WriteLine();
}
verticesOffset += triangulatedMesh.VertexCount;
}
textWriter.Flush();
shapeGeometry.BoundingBox = boundingBox;
((IXbimShapeGeometryData)shapeGeometry).ShapeData = ms.ToArray();
}
return(shapeGeometry);
}
internal static WpfMeshGeometry3D GetRepresentationGeometry2(Material mat, IEnumerable <int> representationLabels, IModel selModel, XbimMatrix3D modelTransform, bool wcsAdjust, XbimShapeGeometry shapegeom, IIfcProduct contextualProduct)
{
var placementTree = new XbimPlacementTree(selModel, wcsAdjust);
var trsf = placementTree[contextualProduct.ObjectPlacement.EntityLabel];
var tgt = new WpfMeshGeometry3D(mat, mat);
tgt.BeginUpdate();
if (shapegeom.Format == XbimGeometryType.PolyhedronBinary)
{
// Debug.WriteLine($"adding {shapegeom.ShapeLabel} at {DateTime.Now.ToLongTimeString()}");
var transform = trsf * modelTransform;
tgt.Add(
((IXbimShapeGeometryData)shapegeom).ShapeData,
contextualProduct.ExpressType.TypeId, // shapeInstance.IfcTypeId,
contextualProduct.EntityLabel, // shapeInstance.IfcProductLabel,
-1, // shapeInstance.InstanceLabel,
transform,
(short)contextualProduct.Model.UserDefinedId
);
}
tgt.EndUpdate();
return(tgt);
}
private void Load()
{
const string fileName = "Assets/ifc/Project1.xBIM";
Debug.Log("initializing model loading");
using (var model = IfcStore.Open(fileName, accessMode: Xbim.IO.Esent.XbimDBAccess.ReadWrite))
{
Debug.Log("model loaded");
if (model.GeometryStore == null)
{
Debug.Log("Geometry Store is null. Model has no geometry information");
}
else
{
Debug.Log("Geometry Store is ok. Starting geometry conversion");
using (var reader = model.GeometryStore.BeginRead())
{
//var shapeGeometries = reader.ShapeGeometries;
var shapeInstances = reader.ShapeInstances;
int shapeInstancesCount = 0;
foreach (XbimShapeInstance shape in shapeInstances)
{
XbimMatrix3D transformation = shape.Transformation;
Matrix4x4 transf = new Matrix4x4(new Vector4((float)transformation.M11, (float)transformation.M12, (float)transformation.M13, (float)transformation.M14),
new Vector4((float)transformation.M21, (float)transformation.M22, (float)transformation.M23, (float)transformation.M24),
new Vector4((float)transformation.M31, (float)transformation.M32, (float)transformation.M33, (float)transformation.M34),
new Vector4((float)transformation.OffsetX, (float)transformation.OffsetY, (float)transformation.OffsetZ, (float)transformation.M44));
if (!geometryInstancesMap.ContainsKey(shape.ShapeGeometryLabel))
{
XbimShapeGeometry geometry = reader.ShapeGeometry(shape.ShapeGeometryLabel);
if (geometry.ShapeData.Length <= 0)
{
continue;
}
Mesh mesh = new Mesh();
//List<Vector3> vertexList = new List<Vector3>();
List <int> triangleList = new List <int>();
var ms = new MemoryStream(((IXbimShapeGeometryData)geometry).ShapeData);
var br = new BinaryReader(ms);
var tr = br.ReadShapeTriangulation();
int size = tr.Vertices.Count;
Vector3[] vertices = Point3DList_to_Vec3Array(tr.Vertices);
//vertexList.AddRange(vertices);
Vector3[] normals = new Vector3[vertices.Length];
int[] normsCount = new int[vertices.Length];
int normalCount = 0;
int faceCount = 0;
IList <XbimFaceTriangulation> facesList = tr.Faces;
//Debug.Log("shape " + shapeInstancesCount + " has " + facesList.Count + " faces");
foreach (XbimFaceTriangulation face in facesList)
{
IList <int> indices = face.Indices;
foreach (int index in indices)
{
triangleList.Add(index);
}
//Debug.Log("face " + faceCount + " has " + indices.Count + " indices");
int i = 0;
if (face.IsPlanar)
{
//Debug.Log("face " + faceCount + " is planar ");
XbimPackedNormal normal = face.Normals[0];
foreach (int index in indices)
{
normals[index] += new Vector3((float)normal.Normal.X, (float)normal.Normal.Y, (float)normal.Normal.Z);
normsCount[index]++;
normalCount++;
}
}
else
{
foreach (XbimPackedNormal normal in face.Normals)
{
int index = face.Indices[i];
normals[index] += new Vector3((float)normal.Normal.X, (float)normal.Normal.Y, (float)normal.Normal.Z);
normsCount[index]++;
normalCount++;
i++;
}
}
faceCount++;
}
for (int i = 0; i < normals.Length; i++)
{
normals[i] = new Vector3(normals[i].x / (float)normsCount[i], normals[i].y / (float)normsCount[i], normals[i].z / (float)normsCount[i]).normalized;
}
//Debug.Log("shape " + shapeInstancesCount + " has " + size + " vertices");
//Debug.Log("shape " + shapeInstancesCount + " has " + XbimShapeTriangulation.TriangleCount(((IXbimShapeGeometryData)geometry).ShapeData) + " triangles");
//Debug.Log("shape " + shapeInstancesCount + " has " + normalCount + " normals");
mesh.vertices = vertices;
mesh.triangles = triangleList.ToArray();
mesh.normals = normals;
container.setMesh(mesh);
triangleList.Clear();
geometryInstancesMap.Add(shape.ShapeGeometryLabel, mesh);
}
else
{
Mesh mesh;
geometryInstancesMap.TryGetValue(shape.ShapeGeometryLabel, out mesh);
if (mesh != null)
{
container.setMesh(mesh);
}
}
MeshContainer obj = Instantiate(container, new Vector3((float)transformation.OffsetX * 0.1f, (float)transformation.OffsetY * 0.1f, (float)transformation.OffsetZ * 0.1f), transf.rotation);
obj.transform.RotateAround(new Vector3(0, 0, 0), new Vector3(1, 0, 0), -90);
obj.transform.localScale = new Vector3(0.1f, 0.1f, 0.1f);
var products = model.Instances.Where <IfcProduct>(e => e.EntityLabel == shape.IfcProductLabel);
int productCount = 0;
foreach (var product in products)
{
obj.name = product.Name.ToString();
//Material mat = obj.GetComponent<MeshRenderer>().material;
var isDefinedBy_inv = product.IsDefinedBy;
foreach (var rel_def in isDefinedBy_inv)
{
IfcPropertySetDefinitionSelect relating_property_def_select = rel_def.RelatingPropertyDefinition;
IfcPropertySetDefinition relating_property_def = (IfcPropertySetDefinition)relating_property_def_select;
if (relating_property_def != null)
{
IfcPropertySet prop_set = (IfcPropertySet)relating_property_def;
if (prop_set != null)
{
Material mat = readAppearanceFromPropertySet(prop_set);
obj.GetComponent <Material>().color = mat.color;
}
continue;
}
IfcPropertySetDefinitionSet relating_property_def_set = (IfcPropertySetDefinitionSet)relating_property_def_select;
if (relating_property_def_set != null)
{
var vec_property_def = relating_property_def_set.PropertySetDefinitions;
foreach (IfcPropertySetDefinition property_def in vec_property_def)
{
if (property_def != null)
{
IfcPropertySet prop_set = (IfcPropertySet)property_def;
if (prop_set != null)
{
Material mat = readAppearanceFromPropertySet(prop_set);
obj.GetComponent <Material>().color = mat.color;
}
}
}
}
}
productCount++;
}
//Debug.Log("there is " + productCount + " products with label " + shape.IfcProductLabel);
shapeInstancesCount++;
//yield return null;
}
container.setMesh(null);
}
Debug.Log("Geometry loaded. Starting visualization.");
} // Close Geometry Store
} // Close File
}
private XbimShapeGeometry MeshPolyhedronBinary(IIfcTriangulatedFaceSet triangulation)
{
XbimShapeGeometry shapeGeometry = new XbimShapeGeometry();
shapeGeometry.Format = XbimGeometryType.PolyhedronBinary;
using (var ms = new MemoryStream(0x4000))
using (var binaryWriter = new BinaryWriter(ms))
{
// Prepare the header
uint verticesCount = (uint)triangulation.Coordinates.CoordList.Count();
uint triangleCount = (uint)triangulation.CoordIndex.Count();
uint facesCount = 1;//at the moment just write one face for all triangles, may change to support styed faces in future
shapeGeometry.BoundingBox = XbimRect3D.Empty;
//Write out the header
binaryWriter.Write((byte)1); //stream format version
// ReSharper disable once RedundantCast
//now write out the faces
if (triangulation.Normals.Any()) //we have normals so obey them
{
List <IEnumerable <IfcPositiveInteger> > normalIndex = new List <IEnumerable <IfcPositiveInteger> >();
bool hasPnIndex = triangulation.PnIndex.Any();
if (hasPnIndex)
{
if (triangulation.PnIndex is List <IItemSet <IfcPositiveInteger> > ) //the list of triplets has not been flattened
{
foreach (var item in triangulation.PnIndex as List <IItemSet <IfcPositiveInteger> > )
{
normalIndex.Add(item);
}
}
else
{
for (int i = 0; i < triangulation.PnIndex.Count; i += 3)
{
var item = new List <IfcPositiveInteger>()
{
triangulation.PnIndex[i], triangulation.PnIndex[i + 1], triangulation.PnIndex[i + 2]
};
normalIndex.Add(item);
}
}
}
else
{
foreach (var item in triangulation.CoordIndex)
{
normalIndex.Add(item);
}
}
binaryWriter.Write(verticesCount); //number of vertices
binaryWriter.Write(triangleCount); //number of triangles
XbimRect3D bb = XbimRect3D.Empty;
foreach (var coordList in triangulation.Coordinates.CoordList)
{
var pt = coordList.AsTriplet();
binaryWriter.Write((float)pt.A);
binaryWriter.Write((float)pt.B);
binaryWriter.Write((float)pt.C);
var rect = new XbimRect3D(pt.A, pt.B, pt.C, 0, 0, 0);
bb.Union(rect);
}
binaryWriter.Write(facesCount);
shapeGeometry.BoundingBox = bb;
Int32 numTrianglesInFace = triangulation.CoordIndex.Count();
binaryWriter.Write(-numTrianglesInFace); //not a planar face so make negative
var packedNormals = new List <XbimPackedNormal>(triangulation.Normals.Count());
foreach (var normal in triangulation.Normals)
{
var tpl = normal.AsTriplet <IfcParameterValue>();
packedNormals.Add(new XbimPackedNormal(tpl.A, tpl.B, tpl.C));
}
int triangleIndex = 0;
foreach (var triangle in triangulation.CoordIndex)
{
var triangleTpl = triangle.AsTriplet();
var normalsIndexTpl = normalIndex[triangleIndex].AsTriplet();
WriteIndex(binaryWriter, (uint)triangleTpl.A - 1, (uint)verticesCount);
packedNormals[(int)normalsIndexTpl.A - 1].Write(binaryWriter);
WriteIndex(binaryWriter, (uint)triangleTpl.B - 1, (uint)verticesCount);
packedNormals[(int)normalsIndexTpl.B - 1].Write(binaryWriter);
WriteIndex(binaryWriter, (uint)triangleTpl.C - 1, (uint)verticesCount);
packedNormals[(int)normalsIndexTpl.C - 1].Write(binaryWriter);
triangleIndex++;
}
}
else //we need to calculate normals to get a better surface fit
{
var triangulatedMesh = Triangulate(triangulation);
shapeGeometry.BoundingBox = triangulatedMesh.BoundingBox;
verticesCount = triangulatedMesh.VertexCount;
triangleCount = triangulatedMesh.TriangleCount;
binaryWriter.Write(verticesCount); //number of vertices
binaryWriter.Write(triangleCount); //number of triangles
foreach (var vert in triangulatedMesh.Vertices)
{
binaryWriter.Write((float)vert.X);
binaryWriter.Write((float)vert.Y);
binaryWriter.Write((float)vert.Z);
}
facesCount = (uint)triangulatedMesh.Faces.Count;
binaryWriter.Write((UInt32)facesCount);
foreach (var faceGroup in triangulatedMesh.Faces)
{
var numTrianglesInFace = faceGroup.Value.Count;
//we need to fix this
var planar = (ushort.MaxValue != faceGroup.Key); //we have a mesh of faces that all have the same normals at their vertices
if (!planar)
{
numTrianglesInFace *= -1; //set flag to say multiple normals
}
// ReSharper disable once RedundantCast
binaryWriter.Write((Int32)numTrianglesInFace);
bool first = true;
foreach (var triangle in faceGroup.Value)
{
if (planar && first)
{
triangle[0].PackedNormal.Write(binaryWriter);
first = false;
}
WriteIndex(binaryWriter, (uint)triangle[0].StartVertexIndex, verticesCount);
if (!planar)
{
triangle[0].PackedNormal.Write(binaryWriter);
}
WriteIndex(binaryWriter, (uint)triangle[0].NextEdge.StartVertexIndex, verticesCount);
if (!planar)
{
triangle[0].NextEdge.PackedNormal.Write(binaryWriter);
}
WriteIndex(binaryWriter, (uint)triangle[0].NextEdge.NextEdge.StartVertexIndex, verticesCount);
if (!planar)
{
triangle[0].NextEdge.NextEdge.PackedNormal.Write(binaryWriter);
}
}
}
}
binaryWriter.Flush();
((IXbimShapeGeometryData)shapeGeometry).ShapeData = ms.ToArray();
}
return(shapeGeometry);
}
private IXbimShapeGeometryData MeshPolyhedronBinary(IEnumerable <IEnumerable <IfcFace> > facesList, int entityLabel, float precision)
{
IXbimShapeGeometryData shapeGeometry = new XbimShapeGeometry();
shapeGeometry.Format = (byte)XbimGeometryType.PolyhedronBinary;
using (var ms = new MemoryStream(0x4000))
using (var binaryWriter = new BinaryWriter(ms))
{
var faceLists = facesList as IList <IEnumerable <IfcFace> > ?? facesList.ToList();
var triangulations = new List <XbimTriangulatedMesh>(faceLists.Count);
foreach (var faceList in faceLists)
{
triangulations.Add(TriangulateFaces(faceList, entityLabel, precision));
}
// Write out header
uint verticesCount = 0;
uint triangleCount = 0;
uint facesCount = 0;
var boundingBox = XbimRect3D.Empty;
foreach (var triangulatedMesh in triangulations)
{
verticesCount += triangulatedMesh.VertexCount;
triangleCount += triangulatedMesh.TriangleCount;
facesCount += (uint)triangulatedMesh.Faces.Count;
if (boundingBox.IsEmpty)
{
boundingBox = triangulatedMesh.BoundingBox;
}
else
{
boundingBox.Union(triangulatedMesh.BoundingBox);
}
}
binaryWriter.Write((byte)1); //stream format version
// ReSharper disable once RedundantCast
binaryWriter.Write((UInt32)verticesCount); //number of vertices
binaryWriter.Write(triangleCount); //number of triangles
foreach (var v in triangulations.SelectMany(t => t.Vertices))
{
binaryWriter.Write(v.X);
binaryWriter.Write(v.Y);
binaryWriter.Write(v.Z);
}
shapeGeometry.BoundingBox = boundingBox.ToFloatArray();
//now write out the faces
binaryWriter.Write(facesCount);
uint verticesOffset = 0;
int invalidNormal = ushort.MaxValue;;
foreach (var triangulatedMesh in triangulations)
{
foreach (var faceGroup in triangulatedMesh.Faces)
{
var numTrianglesInFace = faceGroup.Value.Count;
//we need to fix this
var planar = invalidNormal != faceGroup.Key; //we have a mesh of faces that all have the same normals at their vertices
if (!planar)
{
numTrianglesInFace *= -1; //set flag to say multiple normals
}
binaryWriter.Write((Int32)numTrianglesInFace);
bool first = true;
foreach (var triangle in faceGroup.Value)
{
if (planar && first)
{
triangle[0].PackedNormal.Write(binaryWriter);
first = false;
}
WriteIndex(binaryWriter, (uint)triangle[0].StartVertexIndex + verticesOffset, verticesCount);
if (!planar)
{
triangle[0].PackedNormal.Write(binaryWriter);
}
WriteIndex(binaryWriter, (uint)triangle[0].NextEdge.StartVertexIndex + verticesOffset, verticesCount);
if (!planar)
{
triangle[0].NextEdge.PackedNormal.Write(binaryWriter);
}
WriteIndex(binaryWriter, (uint)triangle[0].NextEdge.NextEdge.StartVertexIndex + verticesOffset,
verticesCount);
if (!planar)
{
triangle[0].NextEdge.NextEdge.PackedNormal.Write(binaryWriter);
}
}
}
verticesOffset += triangulatedMesh.VertexCount;
}
binaryWriter.Flush();
shapeGeometry.ShapeData = ms.ToArray();
}
return(shapeGeometry);
}
internal bool IsShapeGeometryDone(XbimShapeGeometry g) => null != _doneShapeGeometryLabels && _doneShapeGeometryLabels.Contains(g.ShapeLabel);
public int AddShapeGeometry(XbimShapeGeometry shapeGeometry)
{
return(_inMemoryGeometryStore.AddShapeGeometry(shapeGeometry));
}
public void EsentGeometryStoreBatchTest()
{
using (var model = new IO.Esent.EsentModel(ef4))
{
model.CreateFrom("SampleHouse4.ifc", null, null, true);
var store = model.GeometryStore;
using (var txn = store.BeginInit())
{
for (int i = 0; i < 100; i++)
{
//ADD A GEOMETRY SHAPE
var geomData = new XbimShapeGeometry()
{
IfcShapeLabel = 1,
Format = XbimGeometryType.BoundingBox,
GeometryHash = 0,
LOD = XbimLOD.LOD100,
ReferenceCount = 1,
ShapeData = "2123",
BoundingBox = XbimRect3D.Empty
};
var shapeGeomLabel = txn.AddShapeGeometry(geomData);
}
for (int i = 0; i < 100; i++)
{
//ADD A SHAPE INSTANCE
var shapeInstance = new XbimShapeInstance()
{
ShapeGeometryLabel = i + 1
};
var instanceId = txn.AddShapeInstance(shapeInstance, i + 1);
Assert.IsTrue(instanceId == i + 1);
}
for (int i = 0; i < 100; i++)
{
//ADD A SHAPE INSTANCE
var shapeInstance = new XbimShapeInstance()
{
ShapeGeometryLabel = i + 1
};
var instanceId = txn.AddShapeInstance(shapeInstance, i + 1);
Assert.IsTrue(instanceId == i + 101);
}
for (int i = 0; i < 100; i++)
{
//ADD A SHAPE INSTANCE
var shapeInstance = new XbimShapeInstance()
{
ShapeGeometryLabel = i + 1
};
var instanceId = txn.AddShapeInstance(shapeInstance, i + 1);
Assert.IsTrue(instanceId == i + 201);
}
//ADD A REGIONCOLLECTION
var regions = new XbimRegionCollection {
ContextLabel = 50
};
regions.Add(new XbimRegion("region1", XbimRect3D.Empty, 100, XbimMatrix3D.Identity));
txn.AddRegions(regions);
txn.Commit();
}
model.Close();
}
}
public void IfcStoreGeometryGeometryClearTest()
{
using (var model = new IO.Esent.EsentModel(ef4))
{
model.CreateFrom("SampleHouse4.ifc", null, null, true);
var store = model.GeometryStore;
using (var txn = store.BeginInit())
{
//ADD A GEOMETRY SHAPE
var geomData = new XbimShapeGeometry()
{
IfcShapeLabel = 1,
Format = XbimGeometryType.BoundingBox,
GeometryHash = 0,
LOD = XbimLOD.LOD100,
ReferenceCount = 1,
ShapeData = "2123",
BoundingBox = XbimRect3D.Empty
};
var shapeGeomLabel = txn.AddShapeGeometry(geomData);
//ADD A SHAPE INSTANCE
var shapeInstance = new XbimShapeInstance()
{
ShapeGeometryLabel = shapeGeomLabel
};
var instanceId = txn.AddShapeInstance(shapeInstance, shapeGeomLabel);
Assert.IsTrue(instanceId == 1);
//ADD A REGIONCOLLECTION
var regions = new XbimRegionCollection {
ContextLabel = 50
};
regions.Add(new XbimRegion("region1", XbimRect3D.Empty, 100, XbimMatrix3D.Identity));
txn.AddRegions(regions);
txn.Commit();
}
//now redo which should clear the geoemtry
using (var txn = store.BeginInit())
{
Assert.IsNotNull(txn);
//ADD A GEOMETRY SHAPE
var geomData = new XbimShapeGeometry()
{
IfcShapeLabel = 1,
Format = XbimGeometryType.BoundingBox,
GeometryHash = 0,
LOD = XbimLOD.LOD100,
ReferenceCount = 1,
ShapeData = "2123",
BoundingBox = XbimRect3D.Empty
};
var shapeGeomLabel = txn.AddShapeGeometry(geomData);
//ADD A SHAPE INSTANCE
var shapeInstance = new XbimShapeInstance()
{
ShapeGeometryLabel = shapeGeomLabel
};
var instanceId = txn.AddShapeInstance(shapeInstance, shapeGeomLabel);
Assert.IsTrue(instanceId == 1); //if this is 2 it has failed to clear
//ADD A REGIONCOLLECTION
var regions = new XbimRegionCollection {
ContextLabel = 50
};
regions.Add(new XbimRegion("region1", XbimRect3D.Empty, 100, XbimMatrix3D.Identity));
txn.AddRegions(regions);
txn.Commit();
}
model.Close();
}
}
private XbimShapeGeometry MeshPolyhedronBinary(IIfcTriangulatedFaceSet triangulation)
{
XbimShapeGeometry shapeGeometry = new XbimShapeGeometry();
shapeGeometry.Format = XbimGeometryType.PolyhedronBinary;
using (var ms = new MemoryStream(0x4000))
using (var binaryWriter = new BinaryWriter(ms))
{
// Prepare the header
uint verticesCount = (uint)triangulation.Coordinates.CoordList.Count();
uint triangleCount = (uint)triangulation.CoordIndex.Count();
uint facesCount = 1;//at the moment just write one face for all triangles, may change to support styed faces in future
shapeGeometry.BoundingBox = XbimRect3D.Empty;
//Write out the header
binaryWriter.Write((byte)1); //stream format version
// ReSharper disable once RedundantCast
//now write out the faces
if (triangulation.Normals.Any()) //we have normals so obey them
{
List <IEnumerable <IfcPositiveInteger> > normalIndex = new List <IEnumerable <IfcPositiveInteger> >();
bool hasPnIndex = triangulation.PnIndex.Any();
if (hasPnIndex)
{
if (triangulation.PnIndex is List <IItemSet <IfcPositiveInteger> > ) //the list of triplets has not been flattened
{
foreach (var item in triangulation.PnIndex as List <IItemSet <IfcPositiveInteger> > )
{
normalIndex.Add(item);
}
}
else
{
for (int i = 0; i < triangulation.PnIndex.Count; i += 3)
{
var item = new List <IfcPositiveInteger>()
{
triangulation.PnIndex[i], triangulation.PnIndex[i + 1], triangulation.PnIndex[i + 2]
};
normalIndex.Add(item);
}
}
}
else
{
foreach (var item in triangulation.CoordIndex)
{
normalIndex.Add(item);
}
}
binaryWriter.Write(verticesCount); //number of vertices
binaryWriter.Write(triangleCount); //number of triangles
XbimRect3D bb = XbimRect3D.Empty;
// use first point as a local origin for large coordinates. It doesn't matter if
// we use min, max or centroid for this.
var origin = triangulation.Coordinates?.CoordList.FirstOrDefault()?.AsTriplet() ?? new XbimTriplet <IfcLengthMeasure>();
var isLarge = IsLarge(origin.A) || IsLarge(origin.B) || IsLarge(origin.C);
if (isLarge)
{
shapeGeometry.LocalShapeDisplacement = new XbimVector3D(origin.A, origin.B, origin.C);
}
var points = isLarge ?
triangulation.Coordinates.CoordList.Select(c => c.AsTriplet()).Select(t => new XbimTriplet <IfcLengthMeasure> {
A = t.A - origin.A, B = t.B - origin.B, C = t.C - origin.C
}) :
triangulation.Coordinates.CoordList.Select(c => c.AsTriplet());
foreach (var pt in points)
{
binaryWriter.Write((float)pt.A);
binaryWriter.Write((float)pt.B);
binaryWriter.Write((float)pt.C);
var rect = new XbimRect3D(pt.A, pt.B, pt.C, 0, 0, 0);
bb.Union(rect);
}
binaryWriter.Write(facesCount);
shapeGeometry.BoundingBox = bb;
Int32 numTrianglesInFace = triangulation.CoordIndex.Count();
binaryWriter.Write(-numTrianglesInFace); //not a planar face so make negative
var packedNormals = new List <XbimPackedNormal>(triangulation.Normals.Count());
foreach (var normal in triangulation.Normals)
{
var tpl = normal.AsTriplet <IfcParameterValue>();
packedNormals.Add(new XbimPackedNormal(tpl.A, tpl.B, tpl.C));
}
int triangleIndex = 0;
foreach (var triangle in triangulation.CoordIndex)
{
var triangleTpl = triangle.AsTriplet();
var normalsIndexTpl = normalIndex[triangleIndex].AsTriplet();
WriteIndex(binaryWriter, (uint)triangleTpl.A - 1, (uint)verticesCount);
packedNormals[(int)normalsIndexTpl.A - 1].Write(binaryWriter);
WriteIndex(binaryWriter, (uint)triangleTpl.B - 1, (uint)verticesCount);
packedNormals[(int)normalsIndexTpl.B - 1].Write(binaryWriter);
WriteIndex(binaryWriter, (uint)triangleTpl.C - 1, (uint)verticesCount);
packedNormals[(int)normalsIndexTpl.C - 1].Write(binaryWriter);
triangleIndex++;
}
}
else //we need to calculate normals to get a better surface fit
{
var triangulatedMesh = Triangulate(triangulation);
shapeGeometry.BoundingBox = triangulatedMesh.BoundingBox;
verticesCount = triangulatedMesh.VertexCount;
triangleCount = triangulatedMesh.TriangleCount;
binaryWriter.Write(verticesCount); //number of vertices
binaryWriter.Write(triangleCount); //number of triangles
// use minimum bbox as a local origin
var origin = triangulatedMesh.BoundingBox.Min;
var isLarge = IsLarge(origin.X) || IsLarge(origin.Y) || IsLarge(origin.Z);
var vertices = isLarge ?
triangulatedMesh.Vertices.Select(v => new Vec3(v.X - origin.X, v.Y - origin.Y, v.Z - origin.Z)) :
triangulatedMesh.Vertices;
foreach (var vert in vertices)
{
binaryWriter.Write((float)vert.X);
binaryWriter.Write((float)vert.Y);
binaryWriter.Write((float)vert.Z);
}
if (isLarge)
{
var bb = triangulatedMesh.BoundingBox;
shapeGeometry.BoundingBox = new XbimRect3D(bb.X - origin.X, bb.Y = origin.Y, bb.Z - origin.Z, bb.SizeX, bb.SizeY, bb.SizeZ);
shapeGeometry.LocalShapeDisplacement = new XbimVector3D(origin.X, origin.Y, origin.Z);
}
facesCount = (uint)triangulatedMesh.Faces.Count;
binaryWriter.Write((UInt32)facesCount);
foreach (var faceGroup in triangulatedMesh.Faces)
{
var numTrianglesInFace = faceGroup.Value.Count;
//we need to fix this
var planar = (ushort.MaxValue != faceGroup.Key); //we have a mesh of faces that all have the same normals at their vertices
if (!planar)
{
numTrianglesInFace *= -1; //set flag to say multiple normals
}
// ReSharper disable once RedundantCast
binaryWriter.Write((Int32)numTrianglesInFace);
bool first = true;
foreach (var triangle in faceGroup.Value)
{
if (planar && first)
{
triangle[0].PackedNormal.Write(binaryWriter);
first = false;
}
WriteIndex(binaryWriter, (uint)triangle[0].StartVertexIndex, verticesCount);
if (!planar)
{
triangle[0].PackedNormal.Write(binaryWriter);
}
WriteIndex(binaryWriter, (uint)triangle[0].NextEdge.StartVertexIndex, verticesCount);
if (!planar)
{
triangle[0].NextEdge.PackedNormal.Write(binaryWriter);
}
WriteIndex(binaryWriter, (uint)triangle[0].NextEdge.NextEdge.StartVertexIndex, verticesCount);
if (!planar)
{
triangle[0].NextEdge.NextEdge.PackedNormal.Write(binaryWriter);
}
}
}
}
binaryWriter.Flush();
((IXbimShapeGeometryData)shapeGeometry).ShapeData = ms.ToArray();
}
return(shapeGeometry);
}
private XbimShapeGeometry MeshPolyhedronBinary(IEnumerable <IList <IIfcFace> > facesList, int entityLabel, float precision)
{
XbimShapeGeometry shapeGeometry = new XbimShapeGeometry();
shapeGeometry.Format = XbimGeometryType.PolyhedronBinary;
using (var ms = new MemoryStream(0x4000))
using (var binaryWriter = new BinaryWriter(ms))
{
var faceLists = facesList.ToList();
var triangulatedMeshes = new List <XbimTriangulatedMesh>(faceLists.Count);
foreach (var faceList in faceLists)
{
triangulatedMeshes.Add(TriangulateFaces(faceList, entityLabel, precision));
}
// Write out header
uint verticesCount = 0;
uint triangleCount = 0;
uint facesCount = 0;
var boundingBox = XbimRect3D.Empty;
foreach (var triangulatedMesh in triangulatedMeshes)
{
verticesCount += triangulatedMesh.VertexCount;
triangleCount += triangulatedMesh.TriangleCount;
facesCount += (uint)triangulatedMesh.Faces.Count;
if (boundingBox.IsEmpty)
{
boundingBox = triangulatedMesh.BoundingBox;
}
else
{
boundingBox.Union(triangulatedMesh.BoundingBox);
}
}
binaryWriter.Write((byte)1); //stream format version
// ReSharper disable once RedundantCast
binaryWriter.Write((UInt32)verticesCount); //number of vertices
binaryWriter.Write(triangleCount); //number of triangles
// use minimum bbox as a local origin
var origin = boundingBox.Min;
var isLarge = IsLarge(origin.X) || IsLarge(origin.Y) || IsLarge(origin.Z);
var vertices = isLarge ?
triangulatedMeshes.SelectMany(t => t.Vertices).Select(v => new Vec3(v.X - origin.X, v.Y - origin.Y, v.Z - origin.Z)):
triangulatedMeshes.SelectMany(t => t.Vertices);
foreach (var v in vertices)
{
binaryWriter.Write((float)v.X);
binaryWriter.Write((float)v.Y);
binaryWriter.Write((float)v.Z);
}
if (isLarge)
{
var bb = boundingBox;
shapeGeometry.BoundingBox = new XbimRect3D(bb.X - origin.X, bb.Y = origin.Y, bb.Z - origin.Z, bb.SizeX, bb.SizeY, bb.SizeZ);
shapeGeometry.LocalShapeDisplacement = new XbimVector3D(origin.X, origin.Y, origin.Z);
}
else
{
shapeGeometry.BoundingBox = boundingBox;
}
//now write out the faces
binaryWriter.Write(facesCount);
uint verticesOffset = 0;
int invalidNormal = ushort.MaxValue;
foreach (var triangulatedMesh in triangulatedMeshes)
{
foreach (var faceGroup in triangulatedMesh.Faces)
{
var numTrianglesInFace = faceGroup.Value.Count;
//we need to fix this
var planar = invalidNormal != faceGroup.Key; //we have a mesh of faces that all have the same normals at their vertices
if (!planar)
{
numTrianglesInFace *= -1; //set flag to say multiple normals
}
// ReSharper disable once RedundantCast
binaryWriter.Write((Int32)numTrianglesInFace);
bool first = true;
foreach (var triangle in faceGroup.Value)
{
if (planar && first)
{
triangle[0].PackedNormal.Write(binaryWriter);
first = false;
}
WriteIndex(binaryWriter, (uint)triangle[0].StartVertexIndex + verticesOffset, verticesCount);
if (!planar)
{
triangle[0].PackedNormal.Write(binaryWriter);
}
WriteIndex(binaryWriter, (uint)triangle[0].NextEdge.StartVertexIndex + verticesOffset, verticesCount);
if (!planar)
{
triangle[0].NextEdge.PackedNormal.Write(binaryWriter);
}
WriteIndex(binaryWriter, (uint)triangle[0].NextEdge.NextEdge.StartVertexIndex + verticesOffset,
verticesCount);
if (!planar)
{
triangle[0].NextEdge.NextEdge.PackedNormal.Write(binaryWriter);
}
}
}
verticesOffset += triangulatedMesh.VertexCount;
}
binaryWriter.Flush();
((IXbimShapeGeometryData)shapeGeometry).ShapeData = ms.ToArray();
}
return(shapeGeometry);
}
public void EsentGeometryStoreReadTest()
{
using (var model = IO.Esent.EsentModel.CreateTemporaryModel(ef4))
{
var store = model.GeometryStore;
using (var txn = store.BeginInit())
{
//ADD A GEOMETRY SHAPE
var geomData = new XbimShapeGeometry()
{
IfcShapeLabel = 1,
Format = XbimGeometryType.BoundingBox,
GeometryHash = 0,
LOD = XbimLOD.LOD300,
ReferenceCount = 1,
ShapeData = "2123",
BoundingBox = XbimRect3D.Empty
};
var shapeGeomLabel = txn.AddShapeGeometry(geomData);
//ADD A SHAPE INSTANCE
var shapeInstance = new XbimShapeInstance()
{
ShapeGeometryLabel = shapeGeomLabel, RepresentationContext = 50
};
var instanceId = txn.AddShapeInstance(shapeInstance, shapeGeomLabel);
Assert.IsTrue(instanceId == 1);
//ADD 2 REGIONCOLLECTIONS
var regions = new XbimRegionCollection {
ContextLabel = 50
};
regions.Add(new XbimRegion("region1", XbimRect3D.Empty, 100, XbimMatrix3D.Identity));
txn.AddRegions(regions);
regions = new XbimRegionCollection {
ContextLabel = 51
};
regions.Add(new XbimRegion("region2", XbimRect3D.Empty, 100, XbimMatrix3D.Identity));
txn.AddRegions(regions);
txn.Commit();
}
//start to read
using (var reader = store.BeginRead())
{
Assert.IsTrue(reader.ContextRegions.Count() == 2, "Incorrect number of regions retrieved");
var regionsList = reader.ContextRegions.ToList();
var contextIds = reader.ContextIds.ToList();
for (int i = 0; i < reader.ContextRegions.Count(); i++)
{
Assert.IsTrue(regionsList[i].ContextLabel == 50 + i);
Assert.IsTrue(contextIds[i] == 50 + i);
}
Assert.IsTrue(reader.ShapeGeometries.Count() == 1, "Should have returned one shape geometry");
Assert.IsTrue(reader.ShapeGeometries.First().LOD == XbimLOD.LOD300);
Assert.IsTrue(reader.ShapeInstances.Count() == 1, "Should have returned one shape instance");
Assert.IsTrue(reader.ShapeInstances.First().RepresentationContext == 50);
Assert.IsTrue(reader.ShapeInstancesOfContext(50).Count() == 1);
}
model.Close();
}
}
public static List <Point3D> GetFootPrintNonBREP(IIfcProduct ifcElement, Xbim3DModelContext context)
{
var resultList = new List <Point3D>();
foreach (XbimShapeInstance instance in context.ShapeInstancesOf(ifcElement))
{
// Get the IFC Representation of the Footprint of the instance
XbimShapeGeometry geometry = context.ShapeGeometry(instance);
var data = ((IXbimShapeGeometryData)geometry).ShapeData;
using (var stream = new MemoryStream(data))
{
using (var reader = new BinaryReader(stream))
{
XbimShapeTriangulation mesh = reader.ReadShapeTriangulation();
mesh = mesh.Transform(instance.Transformation);
// find the minimal z coordinate
double minZ = 10000;
foreach (var vertex in mesh.Vertices)
{
if (vertex.Z <= minZ)
{
minZ = vertex.Z;
}
}
List <IVertex> points = new List <IVertex>();
foreach (var vertex in mesh.Vertices)
{
if (vertex.Z != minZ)
{
continue;
}
points.Add(new DefaultVertex {
Position = new[] { vertex.X, vertex.Y }
});
}
if (points.Count <= 2)
{
return(null);
}
// Compute ConvexHull
var cH = ConvexHull.Create(points);
foreach (var item in cH.Points)
{
var point = new Point3D()
{
X = item.Position[0], Y = item.Position[1], Z = minZ
};
bool duplicate = false;
foreach (var result in resultList)
{
if (result == point)
{
duplicate = true;
break;
}
}
if (!duplicate)
{
resultList.Add(point);
}
}
}
}
}
return(resultList);
}
