IList <CurveLoop> GetCurveLoops(Document doc, Reference rf)
{
IList <CurveLoop> curveloop = new List <CurveLoop>();
GeometryObject geometryObject = doc.GetElement(rf).GetGeometryObjectFromReference(rf);
try
{
PlanarFace planarFace = geometryObject as PlanarFace;
curveloop = planarFace.GetEdgesAsCurveLoops();
}
catch
{
HermiteFace hermiteFace = geometryObject as HermiteFace;
if (hermiteFace == null)
{
RuledFace ruledFace = geometryObject as RuledFace;
curveloop = ruledFace.GetEdgesAsCurveLoops();
}
else
{
curveloop = hermiteFace.GetEdgesAsCurveLoops();
}
}
return(curveloop);
}
public Result Execute(
ExternalCommandData commandData,
ref string message,
ElementSet elements)
{
UIApplication uiapp = commandData.Application;
uidoc = uiapp.ActiveUIDocument;
Application app = uiapp.Application;
doc = uidoc.Document;
sel = uidoc.Selection;
Reference rf = sel.PickObject(ObjectType.Face, "Select Face");
Element ele = doc.GetElement(rf);
GeometryObject geoobject = ele.GetGeometryObjectFromReference(rf);
PlanarFace face = geoobject as PlanarFace;
Plane plane = face.Faceby3pointPlane();
XYZ direction = face.ComputeNormal(UV.Zero);
using (Transaction tran = new Transaction(doc, "Set view by face"))
{
tran.Start();
SketchPlane skt = SketchPlane.Create(doc, plane);
View3D view3d = doc.ActiveView as View3D;
view3d.OrientTo(plane.Normal);
doc.ActiveView.SketchPlane = skt;
uidoc.RefreshActiveView();
uidoc.ShowElements(ele.Id);
tran.Commit();
}
return(Result.Succeeded);
}
public Result Execute(ExternalCommandData commandData, ref string message, ElementSet elements)
{
UIApplication uiapp = commandData.Application;
UIDocument uidoc = uiapp.ActiveUIDocument;
Document doc = uidoc.Document;
Selection selection = uidoc.Selection;
Reference reff = selection.PickObject(ObjectType.PointOnElement);
Element elem = doc.GetElement(reff);
GeometryObject obj = elem.GetGeometryObjectFromReference(reff);
Category targetCategory = null;
if (obj.GraphicsStyleId != ElementId.InvalidElementId)
{
GraphicsStyle gs = doc.GetElement(obj.GraphicsStyleId) as GraphicsStyle;
if (gs != null)
{
targetCategory = gs.Category;
}
}
using (Transaction ts = new Transaction(doc, "hide selected cad layer"))
{
ts.Start();
doc.ActiveView.SetVisibility(targetCategory, false);
ts.Commit();
}
return(Result.Succeeded);
}
public static List <Solid> Getsolids(this GeometryObject geoobj, Transform trs)
{
var solids = new List <Solid>();
if (geoobj is Solid solid)
{
if (trs != null || trs != Transform.Identity)
{
solid = SolidUtils.CreateTransformed(solid, trs);
}
solids.Add(solid);
}
else if (geoobj is GeometryInstance geoInstance)
{
var transform = geoInstance.Transform;
var symbolgeometry = geoInstance.SymbolGeometry;
var enu = symbolgeometry.GetEnumerator();
while (enu.MoveNext())
{
var temgeoobj = enu.Current as GeometryObject;
solids.AddRange(Getsolids(temgeoobj, transform));
}
}
else if (geoobj is GeometryElement geoElement)
{
var enu = geoElement.GetEnumerator();
while (enu.MoveNext())
{
var temgeoobj = enu.Current as GeometryObject;
solids.AddRange(Getsolids(temgeoobj, trs));
}
}
return(solids);
}
public static GeoRss10Where ToGeoRss10Where(this GeometryObject geom)
{
if (geom is Point)
{
return(((Point)geom).ToGeoRss10Where());
}
if (geom is LineString)
{
return(((LineString)geom).ToGeoRss10Where());
}
if (geom is Polygon)
{
return(((Polygon)geom).ToGeoRss10Where());
}
if (geom is MultiPolygon)
{
return(((MultiPolygon)geom).ToGeoRss10Where());
}
if (geom is MultiPoint)
{
return(((MultiPoint)geom).ToGeoRss10Where());
}
throw new NotImplementedException();
}
public override Value Evaluate(FSharpList <Value> args)
{
var parameter = ((Value.Number)args[0]).Item;
var thisCurve = ((Value.Container)args[1]).Item as Curve;
var thisEdge = (thisCurve != null) ? null : (((Value.Container)args[1]).Item as Edge);
if (thisCurve == null && thisEdge == null && ((Value.Container)args[1]).Item is Reference)
{
var r = (Reference)((Value.Container)args[1]).Item;
if (r != null)
{
var refElem = dynRevitSettings.Doc.Document.GetElement(r.ElementId);
if (refElem != null)
{
GeometryObject geob = refElem.GetGeometryObjectFromReference(r);
thisEdge = geob as Edge;
if (thisEdge == null)
{
thisCurve = geob as Curve;
}
}
}
}
var result = (thisCurve != null) ?
(!XyzOnCurveOrEdge.curveIsReallyUnbound(thisCurve) ? thisCurve.ComputeDerivatives(parameter, true) : thisCurve.ComputeDerivatives(parameter, false))
:
(thisEdge == null ? null : thisEdge.ComputeDerivatives(parameter));
return(Value.NewContainer(result));
}
/// <summary>
/// Located the buttom of a slab object.
/// </summary>
/// <param name="floor">A floor object.</param>
/// <param name="bubbleEnd">The bubble end of new reference plane.</param>
/// <param name="freeEnd">The free end of new reference plane.</param>
/// <param name="thirdPnt">The third point of new reference plane.</param>
private void LocateSlab(Floor floor, ref Autodesk.Revit.DB.XYZ bubbleEnd, ref Autodesk.Revit.DB.XYZ freeEnd, ref Autodesk.Revit.DB.XYZ thirdPnt)
{
//Obtain the geometry data of the floor.
GElement geometry = floor.get_Geometry(m_options);
Face buttomFace = null;
//foreach (GeometryObject go in geometry.Objects)
IEnumerator <GeometryObject> Objects = geometry.GetEnumerator();
while (Objects.MoveNext())
{
GeometryObject go = Objects.Current;
Solid solid = go as Solid;
if (null == solid)
{
continue;
}
else
{
//Get the bottom face of this floor.
buttomFace = GeoHelper.GetBottomFace(solid.Faces);
}
}
Mesh mesh = buttomFace.Triangulate();
GeoHelper.Distribute(mesh, ref bubbleEnd, ref freeEnd, ref thirdPnt);
}
public override IEnumerable <AssociativeNode> BuildOutputAst(List <AssociativeNode> inputAstNodes)
{
GeometryObject geob = null;
string stableRep = string.Empty;
AssociativeNode node;
if (SelectedElement != null)
{
var dbDocument = DocumentManager.Instance.CurrentDBDocument;
if (dbDocument != null)
{
var element = dbDocument.GetElement(SelectedElement);
if (element != null)
{
geob = element.GetGeometryObjectFromReference(SelectedElement);
}
}
stableRep = SelectedElement.ConvertToStableRepresentation(dbDocument);
}
var args = new List <AssociativeNode>
{
AstFactory.BuildStringNode(stableRep)
};
node = AstFactory.BuildFunctionCall(
"GeometryObjectSelector",
"ByReferenceStableRepresentation",
args);
return(new[] { AstFactory.BuildAssignment(GetAstIdentifierForOutputIndex(0), node) });
}
public static IGeoRSS ToGeoRss10(this GeometryObject geom)
{
if (geom is Point)
{
return(((Point)geom).ToGeoRss10Point());
}
if (geom is LineString)
{
return(((LineString)geom).ToGeoRss10Line());
}
if (geom is Polygon && ((Polygon)geom).LineStrings.Count == 1)
{
return(((Polygon)geom).ToGeoRss10Polygon());
}
if (geom is Polygon && ((Polygon)geom).LineStrings.Count > 1)
{
return(((Polygon)geom).ToGeoRss10Where());
}
if (geom is MultiPolygon)
{
return(((MultiPolygon)geom).ToGeoRss10Where());
}
if (geom is MultiPoint)
{
return(((MultiPoint)geom).ToGeoRss10Where());
}
throw new NotImplementedException();
}
/// <summary>
/// generate data of a Mesh
/// </summary>
/// <param name="obj"></param>
/// <param name="transform"></param>
private void AddMesh(GeometryObject obj, Transform transform)
{
Mesh mesh = obj as Mesh;
if (null == mesh)
{
return;
}
//a face has a mesh, all meshes are made of triangles
for (int i = 0; i < mesh.NumTriangles; i++)
{
MeshTriangle triangular = mesh.get_Triangle(i);
List <XYZ> points = new List <XYZ>();
try
{
for (int n = 0; n < 3; n++)
{
Autodesk.Revit.DB.XYZ point = triangular.get_Vertex(n);
Autodesk.Revit.DB.XYZ newPoint = MathUtil.GetBasis(point, transform);
points.Add(newPoint);
}
Autodesk.Revit.DB.XYZ iniPoint = points[0];
points.Add(iniPoint);
m_curve3Ds.Add(points);
}
catch
{
}
}
}
/// <summary>
/// get all planar faces of an extrusion
/// </summary>
/// <param name="extrusion">the extrusion to read</param>
/// <returns>a list of all planar faces of the extrusion</returns>
public List <PlanarFace> GetPlanarFaces(Extrusion extrusion)
{
// the option to get geometry elements
Options m_geoOptions = m_application.Create.NewGeometryOptions();
m_geoOptions.View = m_document.ActiveView;
m_geoOptions.ComputeReferences = true;
// get the planar faces
List <PlanarFace> m_planarFaces = new List <PlanarFace>();
Autodesk.Revit.DB.GeometryElement geoElement = extrusion.get_Geometry(m_geoOptions);
//foreach (GeometryObject geoObject in geoElement.Objects)
IEnumerator <GeometryObject> Objects = geoElement.GetEnumerator();
while (Objects.MoveNext())
{
GeometryObject geoObject = Objects.Current;
Solid geoSolid = geoObject as Solid;
if (null == geoSolid)
{
continue;
}
foreach (Face geoFace in geoSolid.Faces)
{
if (geoFace is PlanarFace)
{
m_planarFaces.Add(geoFace as PlanarFace);
}
}
}
return(m_planarFaces);
}
/// <summary>
/// Extracts solids from a geometry object. see: https://forums.autodesk.com/t5/revit-api-forum/getting-beam-column-and-wall-geometry/td-p/8138893
/// </summary>
/// <param name="gObj"></param>
/// <returns></returns>
public static List <Solid> GetSolids(GeometryObject gObj)
{
List <Solid> solids = new List <Solid>();
if (gObj is Solid) // already solid
{
Solid solid = gObj as Solid;
if (solid.Faces.Size > 0 && Math.Abs(solid.Volume) > 0) // skip invalid solid
{
solids.Add(gObj as Solid);
}
}
else if (gObj is GeometryInstance) // find solids from GeometryInstance
{
IEnumerator <GeometryObject> gIter2 = (gObj as GeometryInstance).GetInstanceGeometry().GetEnumerator();
gIter2.Reset();
while (gIter2.MoveNext())
{
solids.AddRange(GetSolids(gIter2.Current));
}
}
else if (gObj is GeometryElement) // find solids from GeometryElement
{
IEnumerator <GeometryObject> gIter2 = (gObj as GeometryElement).GetEnumerator();
gIter2.Reset();
while (gIter2.MoveNext())
{
solids.AddRange(GetSolids(gIter2.Current));
}
}
return(solids);
}
public static IList <Edge> GetEdgesofGeometryObject(this GeometryObject geoobj)
{
IList <Edge> result = new List <Edge>();
List <Edge> temresult = new List <Edge>();
if (geoobj is GeometryElement)
{
GeometryElement geoele = geoobj as GeometryElement;
foreach (GeometryObject geoitem in geoele)
{
temresult.AddRange(GetEdgesofGeometryObject(geoitem));
}
}
else if (geoobj is GeometryInstance)
{
GeometryElement geoele = (geoobj as GeometryInstance).SymbolGeometry;
foreach (GeometryObject obj in geoele)
{
if (obj is Solid)
{
//result.Add(obj as Face);
temresult.AddRange(GetEdgesofGeometryObject(obj));
}
}
}
else if (geoobj is Solid)
{
Solid solid = geoobj as Solid;
//temresult.Add(solid);
foreach (Face face in solid.Faces)
{
temresult.AddRange(GetEdgesofGeometryObject(face));
}
}
else if (geoobj is Face)
{
Face face = geoobj as Face;
//foreach (EdgeArrayArray edgearrayarray in face.EdgeLoops)
{
foreach (EdgeArray edgeArray in face.EdgeLoops)
{
var enu = edgeArray.GetEnumerator();
while (enu.MoveNext())
{
var edge = enu.Current as Edge;
if (edge != null)
{
temresult.Add(edge);
}
}
}
}
}
else if (geoobj is Edge)
{
temresult.Add(geoobj as Edge);
}
result = temresult;
return(result);
}
public static List <Spatial.Face3D> BottomProfiles(this HostObject hostObject)
{
List <Spatial.Face3D> result = new List <Spatial.Face3D>();
foreach (Reference reference in HostObjectUtils.GetBottomFaces(hostObject))
{
GeometryObject geometryObject = hostObject.GetGeometryObjectFromReference(reference);
if (geometryObject == null)
{
continue;
}
Autodesk.Revit.DB.Face face = geometryObject as Autodesk.Revit.DB.Face;
if (face == null)
{
continue;
}
List <Spatial.Face3D> face3Ds = face.ToSAM();
if (face3Ds == null || face3Ds.Count == 0)
{
continue;
}
result.AddRange(face3Ds);
}
return(result);
}
/// <summary>
/// calculates the restore data
/// </summary>
/// <returns></returns>
public static RestoreData GetRestoreData(GeometryObject geometryObject)
{
Node node = geometryObject as Node;
if (node != null)
{
return(GetRestoreData(node));
}
Edge edge = geometryObject as Edge;
if (edge != null)
{
return(GetRestoreData(edge));
}
Label label = geometryObject as Label;
if (label != null)
{
return(GetRestoreData(label));
}
GeometryGraph graph = geometryObject as GeometryGraph;
if (graph != null)
{
return(GetRestoreData(graph));
}
return(null);
}
public static AbstractGeometryType ToGml(this GeometryObject geometry)
{
if (geometry is Point)
{
return(ToGmlPoint((Point)geometry));
}
if (geometry is MultiPoint)
{
return(ToGmlMultiPoint((MultiPoint)geometry));
}
if (geometry is LineString)
{
return(ToGmlLineString((LineString)geometry));
}
if (geometry is MultiLineString)
{
return(ToGmlMultiCurve((MultiLineString)geometry));
}
if (geometry is Polygon)
{
return(ToGmlPolygon((Polygon)geometry));
}
if (geometry is MultiPolygon)
{
return(ToGmlMultiSurface((MultiPolygon)geometry));
}
return(null);
}
public static Face RequestFaceSelection(string message)
{
var doc = DocumentManager.Instance.CurrentUIDocument;
Face f = null;
Selection choices = doc.Selection;
choices.Elements.Clear();
dynSettings.Controller.DynamoLogger.Log(message);
//create some geometry options so that we computer references
var opts = new Options
{
ComputeReferences = true,
DetailLevel = ViewDetailLevel.Medium,
IncludeNonVisibleObjects = false
};
Reference faceRef = doc.Selection.PickObject(ObjectType.Face);
if (faceRef != null)
{
GeometryObject geob = DocumentManager.Instance.CurrentDBDocument.GetElement(faceRef).GetGeometryObjectFromReference(faceRef);
f = geob as Face;
}
return(f);
}
/// <summary>
/// Sets best material id for current export state.
/// </summary>
/// <param name="geometryObject">The geometry object to get the best material id.</param>
/// <param name="exporterIFC">The ExporterIFC object.</param>
public static void SetBestMaterialIdInExporter(GeometryObject geometryObject, ExporterIFC exporterIFC)
{
ElementId materialId = GetBestMaterialIdForGeometry(geometryObject, exporterIFC);
if (materialId != ElementId.InvalidElementId)
exporterIFC.SetMaterialIdForCurrentExportState(materialId);
}
/// <summary>
/// Extract a 3D solid from a Revit GeometryObject
/// </summary>
/// <param name="geoObject"></param>
/// <param name="_outSolid"></param>
/// <returns></returns>
public static bool TryeGetGeometryDataFromGeometryObject(GeometryObject geoObject, out Solid _outSolid, out DynamoSolid _outDynSolid)
{
DynamoSolid outdynSolid = null;
Solid outSolid = null;
bool success;
// Check if its is a Geometry Instance
if (geoObject is GeometryInstance)
{
GeometryInstance geoInstance = geoObject as GeometryInstance;
foreach (Solid solid in geoInstance.GetInstanceGeometry())
{
// Skip to next element in iteration if any of the following conditions are met
if (null == solid || 0 == solid.Faces.Size || 0 == solid.Edges.Size)
{
continue;
}
DynamoSolid dynSolidGeo = ToDynamoSolid(solid);
// Sometimes a geometry element can be a null solid
if (dynSolidGeo != null)
{
outdynSolid = dynSolidGeo;
outSolid = solid;
}
}
}
// Check if it is Solid
else if (geoObject is Solid)
{
Solid solid = geoObject as Solid;
DynamoSolid dynSolidGeo = ToDynamoSolid(solid);
// Sometimes a geometry element can be a null solid
if (dynSolidGeo != null)
{
outdynSolid = dynSolidGeo;
outSolid = solid;
}
}
if (outdynSolid == null && outSolid == null)
{
success = false;
}
else
{
success = true;
}
_outDynSolid = outdynSolid;
_outSolid = outSolid;
return(success);
}
public override IEnumerable <AssociativeNode> BuildOutputAst(List <AssociativeNode> inputAstNodes)
{
GeometryObject geob = null;
string stableRep = string.Empty;
var dbDocument = DocumentManager.Instance.CurrentDBDocument;
if (SelectedElement == null || dbDocument == null)
{
return(new[] { AstFactory.BuildAssignment(GetAstIdentifierForOutputIndex(0), AstFactory.BuildNullNode()) });
}
if (SelectedElement.UVPoint == null)
{
return(new[] { AstFactory.BuildAssignment(GetAstIdentifierForOutputIndex(0), AstFactory.BuildNullNode()) });
}
var pt = SelectedElement.UVPoint;
//this is a selected point on a face
var ptArgs = new List <AssociativeNode>()
{
AstFactory.BuildDoubleNode(pt.U),
AstFactory.BuildDoubleNode(pt.V)
};
AssociativeNode node = AstFactory.BuildFunctionCall
(
"Autodesk.DesignScript.Geometry.UV",
"ByCoordinates",
ptArgs
);
return(new[] { AstFactory.BuildAssignment(GetAstIdentifierForOutputIndex(0), node) });
}
/// <summary>
/// Gets all solid objects from geometry object.
/// </summary>
/// <param name="gObj">Geometry object from where to get solids. </param>
/// <returns>The solids of the geometry object. </returns>
static public List <Solid> GetSolids(GeometryObject gObj)
{
List <Solid> solids = new List <Solid>();
if (gObj is Solid) // already solid
{
Solid solid = gObj as Solid;
if (solid.Faces.Size > 0 && solid.Volume > 0) // some solid may have not any face?!
{
solids.Add(gObj as Solid);
}
}
else if (gObj is GeometryInstance) // find solids from GeometryInstance
{
IEnumerator <GeometryObject> gIter2 = (gObj as GeometryInstance).GetInstanceGeometry().GetEnumerator();
gIter2.Reset();
while (gIter2.MoveNext())
{
solids.AddRange(GetSolids(gIter2.Current));
}
}
else if (gObj is GeometryElement) // find solids from GeometryElement, this will not happen at all?
{
IEnumerator <GeometryObject> gIter2 = (gObj as GeometryElement).GetEnumerator();
gIter2.Reset();
while (gIter2.MoveNext())
{
solids.AddRange(GetSolids(gIter2.Current));
}
}
return(solids);
}
/// <summary>
/// Tessellate the curves of path reinforcement.
/// </summary>
private void Tessellate()
{
Options option = new Options();
option.DetailLevel = ViewDetailLevel.Fine;
Autodesk.Revit.DB.GeometryElement geoElem = m_pathRein.get_Geometry(option);
//GeometryObjectArray geoArray = geoElem.Objects;
IEnumerator <GeometryObject> Objects = geoElem.GetEnumerator();
//foreach (GeometryObject geo in geoArray)
while (Objects.MoveNext())
{
GeometryObject geo = Objects.Current;
if (geo is Curve)
{
Curve curve = geo as Curve;
m_curves.Add(curve.Tessellate() as List <XYZ>);
}
}
IList <ElementId> curveIds = m_pathRein.GetCurveElementIds();
foreach (ElementId id in curveIds)
{
ModelCurve modelCurve = m_commandData.Application.ActiveUIDocument.Document.GetElement(id) as ModelCurve;
m_path.Add(modelCurve.GeometryCurve.Tessellate() as List <XYZ>);
}
}
/// <summary>
/// The method is used to get extrusion's face along to the specified parameters
/// </summary>
/// <param name="extrusion">the extrusion</param>
/// <param name="view">options view</param>
/// <param name="ExtOrInt">If true indicate getting exterior extrusion face, else getting interior extrusion face</param>
/// <returns>the face</returns>
static public Face GetExtrusionFace(Extrusion extrusion, View view, bool ExtOrInt)
{
Face face = null;
FaceArray faces = null;
if (extrusion.IsSolid)
{
Options options = new Options();
options.ComputeReferences = true;
options.View = view;
//GeometryObjectArray geoArr = extrusion.get_Geometry(options).Objects;
IEnumerator <GeometryObject> Objects = extrusion.get_Geometry(options).GetEnumerator();
//foreach (GeometryObject geoObj in geoArr)
while (Objects.MoveNext())
{
GeometryObject geoObj = Objects.Current;
if (geoObj is Solid)
{
Solid s = geoObj as Solid;
faces = s.Faces;
}
}
if (ExtOrInt)
{
face = GetExteriorFace(faces);
}
else
{
face = GetInteriorFace(faces);
}
}
return(face);
}
/// <summary>
/// generate data of a Geometry Instance.
/// </summary>
/// <param name="obj">a geometry object of element.</param>
private void AddInstance(GeometryObject obj)
{
Autodesk.Revit.DB.GeometryInstance instance = obj as Autodesk.Revit.DB.GeometryInstance;
Autodesk.Revit.DB.GeometryElement geoElement = instance.SymbolGeometry;
AddGeometryElement(geoElement);
}
/// <summary>
/// generate data of a Mesh.
/// </summary>
/// <param name="obj">a geometry object of element.</param>
private void AddMesh(GeometryObject obj)
{
Mesh mesh = obj as Mesh;
List <XYZ> points = new List <XYZ>();
// get all triangles of the mesh.
for (int i = 0; i < mesh.NumTriangles; i++)
{
MeshTriangle trigangle = mesh.get_Triangle(i);
for (int j = 0; j < 3; j++)
{
// A vertex of the triangle.
Autodesk.Revit.DB.XYZ point = trigangle.get_Vertex(j);
double x = point.X;
double y = point.Y;
double z = point.Z;
points.Add(point);
}
Autodesk.Revit.DB.XYZ iniPoint = points[0];
points.Add(iniPoint);
m_curve3Ds.Add(points);
}
}
private void MeshData(GeometryObject obj)
{
Mesh mesh = obj as Mesh;
if (null == mesh)
{
return;
}
StringBuilder str = new StringBuilder();
for (int i = 0; i < mesh.NumTriangles; i++)
{
MeshTriangle triangular = mesh.get_Triangle(i);
List <XYZ> points = new List <XYZ>();
for (int n = 0; n < 3; n++)
{
XYZ point = triangular.get_Vertex(n);
points.Add(point);
str.Append(point.ToString() + "\n");
}
XYZ iniPoint = points[0];
points.Add(iniPoint);
}
TaskDialog td = new TaskDialog("vertex");
td.MainContent = str.ToString();
td.Show();
}
/// <summary>
/// Get geometry of the pathReinforcement
/// </summary>
/// <param name="pathRein">pathReinforcement created</param>
private List <List <XYZ> > GetGeometry(PathReinforcement pathRein)
{
Options options = m_profile.CommandData.Application.Application.Create.NewGeometryOptions();
options.DetailLevel = ViewDetailLevel.Medium;
options.ComputeReferences = true;
Autodesk.Revit.DB.GeometryElement geoElem = pathRein.get_Geometry(options);
List <Curve> curvesList = new List <Curve>();
//GeometryObjectArray gObjects = geoElem.Objects;
IEnumerator <GeometryObject> Objects = geoElem.GetEnumerator();
//foreach (GeometryObject geo in gObjects)
while (Objects.MoveNext())
{
GeometryObject geo = Objects.Current;
Curve curve = geo as Curve;
curvesList.Add(curve);
}
List <List <XYZ> > pointsPreview = new List <List <XYZ> >();
foreach (Curve curve in curvesList)
{
pointsPreview.Add(curve.Tessellate() as List <XYZ>);
}
return(pointsPreview);
}
private void SolidData(GeometryObject obj)
{
Solid solid = obj as Solid;
if (null == solid)
{
return;
}
FaceArray faces = solid.Faces;
if (faces.Size == 0)
{
return;
}
foreach (Face f in faces)
{
Mesh mesh = f.Triangulate();
if (null == mesh)
{
return;
}
MeshData(mesh);
}
}
private static bool FindFaceInGeometryObject(GeometryObject geob, ref Face face)
{
var instance = geob as GeometryInstance;
if (instance != null)
{
foreach (var geob_inner in instance.GetInstanceGeometry())
{
FindFaceInGeometryObject(geob_inner, ref face);
}
}
else
{
var solid = geob as Solid;
if (solid != null)
{
foreach (Face f in solid.Faces)
{
if (f == face)
{
face = f;
return(true);
}
}
}
}
return(false);
}
public static List <Solid> Getsolids(this GeometryObject geoobj)
{
var solids = new List <Solid>();
if (geoobj is Solid solid)
{
solids.Add(solid);
}
else if (geoobj is GeometryInstance geoInstance)
{
var transform = geoInstance.Transform;
var symbolgeometry = geoInstance.SymbolGeometry;
var enu = symbolgeometry.GetEnumerator();
while (enu.MoveNext())
{
var temgeoobj = enu.Current as GeometryObject;
solids.AddRange(Getsolids(temgeoobj));
}
}
else if (geoobj is GeometryElement geoElement)
{
var enu = geoElement.GetEnumerator();
while (enu.MoveNext())
{
var temgeoobj = enu.Current as GeometryObject;
solids.AddRange(Getsolids(temgeoobj));
}
}
return(solids);
}
static private bool RecursionObject(GeometryElement geometryElement, ref List <GeometryObject> geometryObjects)
{
if (geometryElement == null)
{
return(false);
}
IEnumerator <GeometryObject> geometryObjectEnum = geometryElement.GetEnumerator();
while (geometryObjectEnum.MoveNext())
{
GeometryObject currentGeometryObject = geometryObjectEnum.Current;
var type = currentGeometryObject.GetType();
if (type.Equals(typeof(GeometryInstance)))
{
RecursionObject((currentGeometryObject as GeometryInstance).GetInstanceGeometry(), ref geometryObjects);
}
else if (type.Equals(typeof(GeometryElement)))
{
RecursionObject(currentGeometryObject as GeometryElement, ref geometryObjects);
}
else/* if (type.Equals(typeof(Solid)))*/
{
geometryObjects.Add(currentGeometryObject);
}
}
return(true);
}
/// <summary>
/// Initializes a new instance of the <see cref="Feature"/> class.
/// </summary>
/// <param name="geometry">The Geometry Object.</param>
/// <param name="properties">The properties.</param>
public Feature(GeometryObject geometry, Dictionary<string, object> properties)
{
if (properties != null)
this.Properties = properties;
else
this.Properties = new Dictionary<string, object>();
this.Geometry = geometry;
this.Type = GeoJsonObjectType.Feature;
}
/// <summary>
/// Sets best material id for current export state.
/// </summary>
/// <param name="geometryObject">The geometry object to get the best material id.</param>
/// <param name="element">The element to get its structual material if no material found in its geometry.</param>
/// <param name="overrideMaterialId">The material id to override the one gets from geometry object.</param>
/// <param name="exporterIFC">The ExporterIFC object.</param>
/// <returns>The material id.</returns>
public static ElementId SetBestMaterialIdInExporter(GeometryObject geometryObject, Element element, ElementId overrideMaterialId, ExporterIFC exporterIFC)
{
ElementId materialId = overrideMaterialId != ElementId.InvalidElementId ? overrideMaterialId :
GetBestMaterialIdFromGeometryOrParameter(geometryObject, exporterIFC, element);
if (materialId != ElementId.InvalidElementId)
exporterIFC.SetMaterialIdForCurrentExportState(materialId);
return materialId;
}
private static void GetAllCurves(GeometryObject geometry, List<Curve> curves)
{
if (geometry is GeometryElement)
{
GetAllCurves(geometry as GeometryElement, curves);
return;
}
if (geometry is Solid)
{
GetAllCurves(geometry as Solid, curves);
return;
}
}
/// <summary>
/// Tell if the geometry object A and B are overlapped.
/// </summary>
/// <param name="geometryA">geometry object A</param>
/// <param name="geometryB">geometry object B</param>
/// <returns>return true if A and B are overlapped, or else return false.</returns>
public static bool IsOverlapped(GeometryObject geometryA, GeometryObject geometryB)
{
List<Face> facesOfA = new List<Face>();
List<Curve> curvesOfB = new List<Curve>();
GetAllFaces(geometryA, facesOfA);
GetAllCurves(geometryB, curvesOfB);
foreach (Face face in facesOfA)
{
foreach (Curve curve in curvesOfB)
{
if (face.Intersect(curve) == Autodesk.Revit.DB.SetComparisonResult.Overlap)
{
return true;
}
}
}
return false;
}
/// <summary>
/// generate data of a Curve
/// </summary>
/// <param name="obj"></param>
/// <param name="transform"></param>
private void AddCurve(GeometryObject obj, Transform transform)
{
Curve curve = obj as Curve;
if (null == curve)
{
return;
}
if (curve.IsBound)
{
List<XYZ> points = curve.Tessellate() as List<XYZ>;
List<XYZ> result = new List<XYZ>();
foreach (Autodesk.Revit.DB.XYZ point in points)
{
Autodesk.Revit.DB.XYZ newPoint = MathUtil.GetBasis(point, transform);
result.Add(newPoint);
}
m_curve3Ds.Add(result);
}
}
private void Stream(ArrayList data, GeometryObject geomObj)
{
data.Add(new Snoop.Data.ClassSeparator(typeof(GeometryObject)));
data.Add(new Snoop.Data.Bool("IsElementGeometry", geomObj.IsElementGeometry));
data.Add(new Snoop.Data.String("Visibility", geomObj.Visibility.ToString()));
data.Add(new Snoop.Data.ElementId("GraphicStyleId", geomObj.GraphicsStyleId, m_activeDoc));
data.Add(new Snoop.Data.String("Type", geomObj.GetType().Name));
Curve crv = geomObj as Curve;
if (crv != null)
{
Stream(data, crv);
return;
}
Edge edg = geomObj as Edge;
if (edg != null)
{
Stream(data, edg);
return;
}
GeometryElement elem = geomObj as GeometryElement;
if (elem != null)
{
Stream(data, elem);
return;
}
Face face = geomObj as Face;
if (face != null)
{
Stream(data, face);
return;
}
GeometryInstance inst = geomObj as GeometryInstance;
if (inst != null)
{
Stream(data, inst);
return;
}
Mesh mesh = geomObj as Mesh;
if (mesh != null)
{
Stream(data, mesh);
return;
}
Profile prof = geomObj as Profile;
if (prof != null)
{
Stream(data, prof);
return;
}
Solid solid = geomObj as Solid;
if (solid != null)
{
Stream(data, solid);
return;
}
Point point = geomObj as Point;
if (point != null)
{
Stream(data, point);
return;
}
}
/// <summary>
/// Return a triangulated face set from the list of faces
/// </summary>
/// <param name="exporterIFC">exporter IFC</param>
/// <param name="element">the element</param>
/// <param name="options">the body export options</param>
/// <param name="geomObject">the geometry object</param>
/// <returns>returns the handle</returns>
private static IFCAnyHandle ExportSurfaceAsTriangulatedFaceSet(ExporterIFC exporterIFC, Element element, BodyExporterOptions options,
GeometryObject geomObject)
{
IFCFile file = exporterIFC.GetFile();
List<List<XYZ>> triangleList = new List<List<XYZ>>();
if (geomObject is Solid)
{
Solid geomSolid = geomObject as Solid;
FaceArray faces = geomSolid.Faces;
foreach (Face face in faces)
{
double tessellationLevel = options.TessellationControls.LevelOfDetail;
Mesh faceTriangulation = face.Triangulate(tessellationLevel);
for (int i = 0; i < faceTriangulation.NumTriangles; ++i)
{
List<XYZ> triangleVertices = new List<XYZ>();
MeshTriangle triangle = faceTriangulation.get_Triangle(i);
for (int tri = 0; tri < 3; ++tri)
{
XYZ vert = triangle.get_Vertex(tri);
triangleVertices.Add(vert);
}
triangleList.Add(triangleVertices);
}
}
}
else if (geomObject is Mesh)
{
Mesh geomMesh = geomObject as Mesh;
for (int i = 0; i < geomMesh.NumTriangles; ++i)
{
List<XYZ> triangleVertices = new List<XYZ>();
MeshTriangle triangle = geomMesh.get_Triangle(i);
for (int tri = 0; tri < 3; ++tri)
{
XYZ vert = triangle.get_Vertex(tri);
triangleVertices.Add(vert);
}
triangleList.Add(triangleVertices);
}
}
return GeometryUtil.GetIndexedTriangles(file, triangleList);
}
private static void ParseSolid(GeometryObject obj, List<XYZ> pts)
{
var solid = obj as Solid;
foreach (Edge gEdge in solid.Edges)
{
Curve c = gEdge.AsCurve();
if (c is Line)
{
pts.Add(c.Evaluate(0, true));
pts.Add(c.Evaluate(1,true));
}
else
{
IList<XYZ> xyzArray = gEdge.Tessellate();
pts.AddRange(xyzArray);
}
}
}
private static bool ProcessObjectForGStyle(Document doc, GeometryObject geomObj, ref ElementId overrideCatId, ref bool initOverrideCatId)
{
GraphicsStyle gStyle = doc.GetElement(geomObj.GraphicsStyleId) as GraphicsStyle;
if (gStyle == null)
return true;
if (gStyle.GraphicsStyleCategory == null)
return true;
ElementId currCatId = gStyle.GraphicsStyleCategory.Id;
if (currCatId == ElementId.InvalidElementId)
return true;
if (!initOverrideCatId)
{
initOverrideCatId = true;
overrideCatId = currCatId;
return true;
}
if (currCatId != overrideCatId)
{
overrideCatId = ElementId.InvalidElementId;
return false;
}
return true;
}
/// <summary>
/// Exports a geometry object to IFC body representation.
/// </summary>
/// <param name="exporterIFC">The ExporterIFC object.</param>
/// <param name="categoryId">The category id.</param>
/// <param name="geometryObject">The geometry object.</param>
/// <param name="options">The settings for how to export the body.</param>
/// <param name="exportBodyParams">The extrusion creation data.</param>
/// <returns>The body data.</returns>
public static BodyData ExportBody(ExporterIFC exporterIFC,
Element element, ElementId categoryId, ElementId overrideMaterialId,
GeometryObject geometryObject, BodyExporterOptions options,
IFCExtrusionCreationData exportBodyParams)
{
IList<GeometryObject> geomList = new List<GeometryObject>();
if (geometryObject is Solid)
{
IList<Solid> splitVolumes = GeometryUtil.SplitVolumes(geometryObject as Solid);
foreach (Solid solid in splitVolumes)
geomList.Add(solid);
}
else
geomList.Add(geometryObject);
return ExportBody(exporterIFC, element, categoryId, overrideMaterialId, geomList, options, exportBodyParams);
}
/// <summary>
/// generate data of a Profile
/// </summary>
/// <param name="obj"></param>
/// <param name="transform"></param>
private void AddProfile(GeometryObject obj, Transform transform)
{
Profile profile = obj as Profile;
if (null == profile)
{
return;
}
foreach (Curve curve in profile.Curves)
{
AddCurve(curve, transform);
}
}
private static bool ExportBodyAsSolid(ExporterIFC exporterIFC, Element element, BodyExporterOptions options,
IList<HashSet<IFCAnyHandle>> currentFaceHashSetList, GeometryObject geomObject)
{
IFCFile file = exporterIFC.GetFile();
Document document = element.Document;
bool exportedAsSolid = false;
try
{
if (geomObject is Solid)
{
Solid solid = geomObject as Solid;
exportedAsSolid = ExportPlanarBodyIfPossible(exporterIFC, solid, currentFaceHashSetList);
if (exportedAsSolid)
return exportedAsSolid;
SolidOrShellTessellationControls tessellationControls = options.TessellationControls;
TriangulatedSolidOrShell solidFacetation =
SolidUtils.TessellateSolidOrShell(solid, tessellationControls);
if (solidFacetation.ShellComponentCount == 1)
{
TriangulatedShellComponent component = solidFacetation.GetShellComponent(0);
int numberOfTriangles = component.TriangleCount;
int numberOfVertices = component.VertexCount;
if (numberOfTriangles > 0 && numberOfVertices > 0)
{
IList<IFCAnyHandle> vertexHandles = new List<IFCAnyHandle>();
HashSet<IFCAnyHandle> currentFaceSet = new HashSet<IFCAnyHandle>();
// create list of vertices first.
for (int ii = 0; ii < numberOfVertices; ii++)
{
XYZ vertex = component.GetVertex(ii);
XYZ vertexScaled = ExporterIFCUtils.TransformAndScalePoint(exporterIFC, vertex);
IFCAnyHandle vertexHandle = ExporterUtil.CreateCartesianPoint(file, vertexScaled);
vertexHandles.Add(vertexHandle);
}
try
{
IList<LinkedList<int>> facets = ConvertTrianglesToPlanarFacets(component);
foreach (LinkedList<int> facet in facets)
{
IList<IFCAnyHandle> vertices = new List<IFCAnyHandle>();
int numVertices = facet.Count;
if (numVertices < 3)
continue;
foreach (int vertexIndex in facet)
{
vertices.Add(vertexHandles[vertexIndex]);
}
IFCAnyHandle faceOuterLoop = IFCInstanceExporter.CreatePolyLoop(file, vertices);
IFCAnyHandle faceOuterBound = IFCInstanceExporter.CreateFaceOuterBound(file, faceOuterLoop, true);
HashSet<IFCAnyHandle> faceBounds = new HashSet<IFCAnyHandle>();
faceBounds.Add(faceOuterBound);
IFCAnyHandle face = IFCInstanceExporter.CreateFace(file, faceBounds);
currentFaceSet.Add(face);
}
}
catch
{
for (int ii = 0; ii < numberOfTriangles; ii++)
{
TriangleInShellComponent triangle = component.GetTriangle(ii);
IList<IFCAnyHandle> vertices = new List<IFCAnyHandle>();
vertices.Add(vertexHandles[triangle.VertexIndex0]);
vertices.Add(vertexHandles[triangle.VertexIndex1]);
vertices.Add(vertexHandles[triangle.VertexIndex2]);
IFCAnyHandle faceOuterLoop = IFCInstanceExporter.CreatePolyLoop(file, vertices);
IFCAnyHandle faceOuterBound = IFCInstanceExporter.CreateFaceOuterBound(file, faceOuterLoop, true);
HashSet<IFCAnyHandle> faceBounds = new HashSet<IFCAnyHandle>();
faceBounds.Add(faceOuterBound);
IFCAnyHandle face = IFCInstanceExporter.CreateFace(file, faceBounds);
currentFaceSet.Add(face);
}
}
finally
{
currentFaceHashSetList.Add(currentFaceSet);
exportedAsSolid = true;
}
}
}
}
return exportedAsSolid;
}
catch
{
string errMsg = String.Format("TessellateSolidOrShell failed in IFC export for element \"{0}\" with id {1}", element.Name, element.Id);
document.Application.WriteJournalComment(errMsg, false/*timestamp*/);
return false;
}
}
/// <summary>
/// Create an IFCSolidInfo from the created geometry.
/// </summary>
/// <param name="id">The id associated with the geometry in the IFC file.</param>
/// <param name="geometryObject">The created geometry.</param>
/// <returns>The IFCSolidInfo class.</returns>
public static IFCSolidInfo Create(int id, GeometryObject geometryObject)
{
return new IFCSolidInfo(id, geometryObject);
}
/// <summary>
/// generate data of a Solid
/// </summary>
/// <param name="obj"></param>
/// <param name="transform"></param>
private void AddSolid(GeometryObject obj, Transform transform)
{
Solid solid = obj as Solid;
if (null == solid)
{
return;
}
//a solid has many faces
FaceArray faces = solid.Faces;
if (faces.Size == 0)
{
return;
}
foreach (Face face in faces)
{
AddFace(face, transform);
}
}
protected IFCSolidInfo(int id, GeometryObject geometryObject)
{
Id = id;
GeometryObject = geometryObject;
}
protected IFCSolidInfo()
{
Id = -1;
GeometryObject = null;
}
private static void ParseInstanceGeometry(GeometryObject obj, List<XYZ> pts)
{
var geomInst = obj as GeometryInstance;
foreach (GeometryObject gObj in geomInst.GetInstanceGeometry())
{
if (gObj is Solid)
{
ParseSolid(gObj, pts);
}
else if (gObj is GeometryInstance)
{
ParseInstanceGeometry(gObj, pts);
}
}
}
private static bool FindFaceInGeometryObject(GeometryObject geob, ref Face face)
{
var instance = geob as GeometryInstance;
if (instance != null)
{
foreach (var geob_inner in instance.GetInstanceGeometry())
{
FindFaceInGeometryObject(geob_inner, ref face);
}
}
else
{
var solid = geob as Solid;
if (solid != null)
{
foreach (Face f in solid.Faces)
{
if (f == face)
{
face = f;
return true;
}
}
}
}
return false;
}
/// <summary>
/// generate data of a Mesh
/// </summary>
/// <param name="obj"></param>
/// <param name="transform"></param>
private void AddMesh(GeometryObject obj, Transform transform)
{
Mesh mesh = obj as Mesh;
if (null == mesh)
{
return;
}
//a face has a mesh, all meshes are made of triangles
for (int i = 0; i < mesh.NumTriangles; i++)
{
MeshTriangle triangular = mesh.get_Triangle(i);
List<XYZ> points = new List<XYZ>();
try
{
for (int n = 0; n < 3; n++)
{
Autodesk.Revit.DB.XYZ point = triangular.get_Vertex(n);
Autodesk.Revit.DB.XYZ newPoint = MathUtil.GetBasis(point, transform);
points.Add(newPoint);
}
Autodesk.Revit.DB.XYZ iniPoint = points[0];
points.Add(iniPoint);
m_curve3Ds.Add(points);
}
catch
{
}
}
}
/// <summary>
/// Adds a new object to the cache.
/// </summary>
/// <param name="geometryObject">The object.</param>
public void AddGeometryObject(GeometryObject geometryObject)
{
m_geometryObjects.Add(geometryObject);
}
/// <summary>
/// generate data of a Instance
/// </summary>
/// <param name="obj"></param>
/// <param name="transform"></param>
private void AddInstance(GeometryObject obj, Transform transform)
{
GeometryInstance instance = obj as GeometryInstance;
if (null == instance)
{
return;
}
//get a transformation of the affine 3-space
Transform allTransform = AddTransform(transform, instance.Transform);
GeometryElement instanceGeometry = instance.SymbolGeometry;
if (null == instanceGeometry)
{
return;
}
//get all geometric primitives contained in the GeometryElement
GeometryObjectArray instanceGeometries = instanceGeometry.Objects;
AddGeometryObjects(instanceGeometries, allTransform);
}
/// <summary>
/// Exports a geometry object to IFC body representation.
/// </summary>
/// <param name="application">The Revit application.</param>
/// <param name="exporterIFC">The ExporterIFC object.</param>
/// <param name="categoryId">The category id.</param>
/// <param name="geometryObject">The geometry object.</param>
/// <param name="options">The settings for how to export the body.</param>
/// <param name="exportBodyParams">The extrusion creation data.</param>
/// <returns>The body data.</returns>
public static BodyData ExportBody(Autodesk.Revit.ApplicationServices.Application application, ExporterIFC exporterIFC,
Element element, ElementId categoryId,
GeometryObject geometryObject, BodyExporterOptions options,
IFCExtrusionCreationData exportBodyParams)
{
IList<GeometryObject> geomList = new List<GeometryObject>();
geomList.Add(geometryObject);
return ExportBody(application, exporterIFC, element, categoryId, geomList, options, exportBodyParams);
}
/// <summary>
/// get the solids in a Geometric primitive
/// </summary>
/// <param name="obj">a geometry object of element</param>
/// <param name="transform"></param>
private void AddGeoElement(GeometryObject obj, Transform transform)
{
GeometryElement geometry = obj as GeometryElement;
if (null == geometry)
{
return;
}
//get all geometric primitives contained in the GeometryElement
GeometryObjectArray geometries = geometry.Objects;
AddGeometryObjects(geometries, transform);
}
/// <summary>
/// Gets the best material id from the geometry or its structural material parameter.
/// </summary>
/// <param name="geometryObject">The geometry object.</param>
/// <param name="exporterIFC">The exporter.</param>
/// <param name="element">The element.</param>
/// <returns>The material id.</returns>
public static ElementId GetBestMaterialIdFromGeometryOrParameter(GeometryObject geometryObject, ExporterIFC exporterIFC, Element element)
{
ElementId matId = GetBestMaterialIdForGeometry(geometryObject, exporterIFC);
if (matId == ElementId.InvalidElementId && element != null)
matId = GetBestMaterialIdFromParameter(element);
return matId;
}
/// <summary>
/// generate data of a Face
/// </summary>
/// <param name="obj"></param>
/// <param name="transform"></param>
private void AddFace(GeometryObject obj, Transform transform)
{
Face face = obj as Face;
if (null == face)
{
return;
}
Mesh mesh = face.Triangulate();
if (null == mesh)
{
return;
}
AddMesh(mesh, transform);
}
private static bool ExportBodyAsSolid(ExporterIFC exporterIFC, Element element, BodyExporterOptions options,
IList<HashSet<IFCAnyHandle>> currentFaceHashSetList, GeometryObject geomObject)
{
IFCFile file = exporterIFC.GetFile();
Document document = element.Document;
bool exportedAsSolid = false;
try
{
if (geomObject is Solid)
{
Solid solid = geomObject as Solid;
exportedAsSolid = ExportPlanarBodyIfPossible(exporterIFC, solid, currentFaceHashSetList);
if (exportedAsSolid)
return exportedAsSolid;
SolidOrShellTessellationControls tessellationControlsOriginal = options.TessellationControls;
SolidOrShellTessellationControls tessellationControls = ExporterUtil.GetTessellationControl(element, tessellationControlsOriginal);
TriangulatedSolidOrShell solidFacetation = null;
// We will make (up to) 2 attempts. First we will use tessellationControls, and then we will try tessellationControlsOriginal, but only
// if they are different.
for (int ii = 0; ii < 2; ii++)
{
if (ii == 1 && tessellationControls.Equals(tessellationControlsOriginal))
break;
try
{
SolidOrShellTessellationControls tessellationControlsToUse = (ii == 0) ? tessellationControls : tessellationControlsOriginal;
solidFacetation = SolidUtils.TessellateSolidOrShell(solid, tessellationControlsToUse);
break;
}
catch
{
solidFacetation = null;
}
}
// Only handle one solid or shell.
if (solidFacetation != null && solidFacetation.ShellComponentCount == 1)
{
TriangulatedShellComponent component = solidFacetation.GetShellComponent(0);
int numberOfTriangles = component.TriangleCount;
int numberOfVertices = component.VertexCount;
// We are going to limit the number of triangles to 50,000. This is a arbitrary number
// that should prevent the solid faceter from creating too many extra triangles to sew the surfaces.
// We may evaluate this number over time.
if ((numberOfTriangles > 0 && numberOfVertices > 0) && (numberOfTriangles < 50000))
{
IList<IFCAnyHandle> vertexHandles = new List<IFCAnyHandle>();
HashSet<IFCAnyHandle> currentFaceSet = new HashSet<IFCAnyHandle>();
if (ExporterCacheManager.ExportOptionsCache.ExportAs4ReferenceView)
{
List<List<double>> coordList = new List<List<double>>();
// create list of vertices first.
for (int i = 0; i < numberOfVertices; i++)
{
List<double> vertCoord = new List<double>();
XYZ vertex = component.GetVertex(i);
XYZ vertexScaled = ExporterIFCUtils.TransformAndScalePoint(exporterIFC, vertex);
vertCoord.Add(vertexScaled.X);
vertCoord.Add(vertexScaled.Y);
vertCoord.Add(vertexScaled.Z);
coordList.Add(vertCoord);
}
}
else
{
// create list of vertices first.
for (int ii = 0; ii < numberOfVertices; ii++)
{
XYZ vertex = component.GetVertex(ii);
XYZ vertexScaled = ExporterIFCUtils.TransformAndScalePoint(exporterIFC, vertex);
IFCAnyHandle vertexHandle = ExporterUtil.CreateCartesianPoint(file, vertexScaled);
vertexHandles.Add(vertexHandle);
}
if (!ExportPlanarFacetsIfPossible(file, component, vertexHandles, currentFaceSet))
{
// Export all of the triangles instead.
for (int ii = 0; ii < numberOfTriangles; ii++)
{
TriangleInShellComponent triangle = component.GetTriangle(ii);
IList<IFCAnyHandle> vertices = new List<IFCAnyHandle>();
vertices.Add(vertexHandles[triangle.VertexIndex0]);
vertices.Add(vertexHandles[triangle.VertexIndex1]);
vertices.Add(vertexHandles[triangle.VertexIndex2]);
IFCAnyHandle face = CreateFaceFromVertexList(file, vertices);
currentFaceSet.Add(face);
}
}
currentFaceHashSetList.Add(currentFaceSet);
exportedAsSolid = true;
}
}
}
}
return exportedAsSolid;
}
catch
{
string errMsg = String.Format("TessellateSolidOrShell failed in IFC export for element \"{0}\" with id {1}", element.Name, element.Id);
document.Application.WriteJournalComment(errMsg, false/*timestamp*/);
return false;
}
}
/// <summary>
/// generate data of a Edge
/// </summary>
/// <param name="obj"></param>
/// <param name="transform"></param>
private void AddEdge(GeometryObject obj, Transform transform)
{
Edge edge = obj as Edge;
if (null == edge)
{
return;
}
List<XYZ> points = edge.Tessellate() as List<XYZ>;
List<XYZ> result = new List<XYZ>();
foreach (Autodesk.Revit.DB.XYZ point in points)
{
Autodesk.Revit.DB.XYZ newPoint = MathUtil.GetBasis(point, transform);
result.Add(newPoint);
}
m_curve3Ds.Add(result);
}
/// <summary>
/// Gets the best material id for the geometry.
/// </summary>
/// <param name="geometryObject">The geometry object to get the best material id.</param>
/// <param name="exporterIFC">The ExporterIFC object.</param>
/// <returns>The material id.</returns>
public static ElementId GetBestMaterialIdForGeometry(GeometryObject geometryObject, ExporterIFC exporterIFC)
{
if (geometryObject is GeometryElement)
return GetBestMaterialIdForGeometry(geometryObject as GeometryElement, exporterIFC, null);
if (!(geometryObject is Solid))
return ElementId.InvalidElementId;
Solid solid = geometryObject as Solid;
// We need to figure out the most common material id for the internal faces.
// Other faces will override this.
IDictionary<ElementId, int> countMap = new Dictionary<ElementId, int>();
ElementId mostPopularId = ElementId.InvalidElementId;
int numMostPopular = 0;
foreach (Face face in solid.Faces)
{
if (face == null)
continue;
ElementId currentMaterialId = face.MaterialElementId;
if (currentMaterialId == ElementId.InvalidElementId)
continue;
int currentCount = 0;
if (countMap.ContainsKey(currentMaterialId))
{
countMap[currentMaterialId]++;
currentCount = countMap[currentMaterialId];
}
else
{
countMap[currentMaterialId] = 1;
currentCount = 1;
}
if (currentCount > numMostPopular)
{
mostPopularId = currentMaterialId;
numMostPopular = currentCount;
}
}
return mostPopularId;
}
/// <summary>
/// Creates a SweptSolidExporter.
/// </summary>
/// <param name="exporterIFC">The exporter.</param>
/// <param name="element">The element.</param>
/// <param name="solid">The solid.</param>
/// <param name="normal">The normal of the plane that the path lies on.</param>
/// <returns>The SweptSolidExporter.</returns>
public static SweptSolidExporter Create(ExporterIFC exporterIFC, Element element, SimpleSweptSolidAnalyzer sweptAnalyzer, GeometryObject geomObject)
{
try
{
if (sweptAnalyzer == null)
return null;
SweptSolidExporter sweptSolidExporter = null;
IList<Revit.IFC.Export.Utility.GeometryUtil.FaceBoundaryType> faceBoundaryTypes;
IList<CurveLoop> faceBoundaries = GeometryUtil.GetFaceBoundaries(sweptAnalyzer.ProfileFace, null, out faceBoundaryTypes);
string profileName = null;
if (element != null)
{
ElementType type = element.Document.GetElement(element.GetTypeId()) as ElementType;
if (type != null)
profileName = type.Name;
}
// Is it really an extrusion?
if (sweptAnalyzer.PathCurve is Line)
{
Line line = sweptAnalyzer.PathCurve as Line;
// invalid case
if (MathUtil.VectorsAreOrthogonal(line.Direction, sweptAnalyzer.ProfileFace.FaceNormal))
return null;
sweptSolidExporter = new SweptSolidExporter();
sweptSolidExporter.RepresentationType = ShapeRepresentationType.SweptSolid;
Plane plane = new Plane(sweptAnalyzer.ProfileFace.FaceNormal, sweptAnalyzer.ProfileFace.Origin);
sweptSolidExporter.RepresentationItem = ExtrusionExporter.CreateExtrudedSolidFromCurveLoop(exporterIFC, profileName, faceBoundaries, plane,
line.Direction, UnitUtil.ScaleLength(line.Length));
}
else
{
sweptSolidExporter = new SweptSolidExporter();
if (ExporterCacheManager.ExportOptionsCache.ExportAs4)
{
// Use tessellated geometry in IFC Reference View
if (ExporterCacheManager.ExportOptionsCache.ExportAs4ReferenceView)
{
// TODO: Create CreateSimpleSweptSolidAsTessellation routine that takes advantage of the superior tessellation of this class.
BodyExporterOptions options = new BodyExporterOptions(false);
sweptSolidExporter.RepresentationItem = BodyExporter.ExportBodyAsTriangulatedFaceSet(exporterIFC, element, options, geomObject);
sweptSolidExporter.RepresentationType = ShapeRepresentationType.Tessellation;
}
else
{
sweptSolidExporter.RepresentationItem = CreateSimpleSweptSolid(exporterIFC, profileName, faceBoundaries, sweptAnalyzer.ReferencePlaneNormal, sweptAnalyzer.PathCurve);
sweptSolidExporter.RepresentationType = ShapeRepresentationType.AdvancedSweptSolid;
}
}
else
{
sweptSolidExporter.Facets = CreateSimpleSweptSolidAsBRep(exporterIFC, profileName, faceBoundaries, sweptAnalyzer.ReferencePlaneNormal, sweptAnalyzer.PathCurve);
sweptSolidExporter.RepresentationType = ShapeRepresentationType.Brep;
}
}
return sweptSolidExporter;
}
catch (Exception)
{
return null;
}
}
