/// <summary>
/// Calculates net volume.
/// </summary>
/// <param name="exporterIFC">
/// The ExporterIFC object.
/// </param>
/// <param name="extrusionCreationData">
/// The IFCExtrusionCreationData.
/// </param>
/// <param name="element">
/// The element to calculate the value.
/// </param>
/// <param name="elementType">
/// The element type.
/// </param>
/// <returns>
/// True if the operation succeed, false otherwise.
/// </returns>
public override bool Calculate(ExporterIFC exporterIFC, IFCExtrusionCreationData extrusionCreationData, Element element, ElementType elementType, EntryMap entryMap)
{
double volumeEps = MathUtil.Eps() * MathUtil.Eps() * MathUtil.Eps();
if ((ParameterUtil.GetDoubleValueFromElementOrSymbol(element, entryMap.RevitParameterName, out m_Volume) != null) ||
(ParameterUtil.GetDoubleValueFromElementOrSymbol(element, entryMap.CompatibleRevitParameterName, out m_Volume) != null) ||
(ParameterUtil.GetDoubleValueFromElementOrSymbol(element, "IfcQtyNetVolume", out m_Volume) != null))
{
m_Volume = UnitUtil.ScaleVolume(m_Volume);
if (m_Volume > volumeEps)
{
return(true);
}
}
double vol = 0;
SolidMeshGeometryInfo geomInfo = GeometryUtil.GetSolidMeshGeometry(element);
if (geomInfo.SolidsCount() > 0)
{
for (int ii = 0; ii < geomInfo.SolidsCount(); ++ii)
{
vol += geomInfo.GetSolids()[ii].Volume;
}
}
if (geomInfo.MeshesCount() > 0)
{
for (int jj = 0; jj < geomInfo.MeshesCount(); ++jj)
{
Mesh geomMesh = geomInfo.GetMeshes()[jj];
XYZ arbitraryOrig = geomMesh.Vertices[0];
for (int i = 0; i < geomMesh.NumTriangles; ++i)
{
MeshTriangle meshTri = geomMesh.get_Triangle(i);
XYZ v1 = meshTri.get_Vertex(0) - arbitraryOrig;
XYZ v2 = meshTri.get_Vertex(1) - arbitraryOrig;
XYZ v3 = meshTri.get_Vertex(2) - arbitraryOrig;
vol += v1.DotProduct(v2.CrossProduct(v3)) / 6.0f;
}
}
}
m_Volume = UnitUtil.ScaleVolume(vol);
return(m_Volume > volumeEps);
}
/// <summary>
/// Calculates the reference.
/// </summary>
/// <param name="exporterIFC">
/// The ExporterIFC object.
/// </param>
/// <param name="extrusionCreationData">
/// The IFCExtrusionCreationData.
/// </param>
/// <param name="element">
/// The element to calculate the value.
/// </param>
/// <param name="elementType">
/// The element type.
/// </param>
/// <returns>
/// True if the operation succeed, false otherwise.
/// </returns>
public override bool Calculate(ExporterIFC exporterIFC, IFCExtrusionCreationData extrusionCreationData, Element element, ElementType elementType, EntryMap entryMap)
{
if (ParameterUtil.GetStringValueFromElementOrSymbol(element, entryMap.RevitParameterName, out m_FireRating) == null)
{
if (ParameterUtil.GetStringValueFromElementOrSymbol(element, entryMap.CompatibleRevitParameterName, out m_FireRating) == null)
{
ParameterUtil.GetStringValueFromElementOrSymbol(element, "Fire Rating", out m_FireRating);
}
}
if (!string.IsNullOrEmpty(m_FireRating))
{
return(true);
}
return(false);
}
/// <summary>
/// Calculates the shape for a provision for void.
/// </summary>
/// <param name="exporterIFC">The ExporterIFC object.</param>
/// <param name="extrusionCreationData">The IFCExtrusionCreationData.</param>
/// <param name="element">The element to calculate the value.</param>
/// <param name="elementType">The element type.</param>
/// <returns>
/// True if the operation succeed, false otherwise.
/// </returns>
public override bool Calculate(ExporterIFC exporterIFC, IFCExtrusionCreationData extrusionCreationData, Element element, ElementType elementType, EntryMap entryMap)
{
if (extrusionCreationData == null)
{
return(false);
}
IFCAnyHandle provisionForVoidHnd = ExporterCacheManager.ElementToHandleCache.Find(element.Id);
if (IFCAnyHandleUtil.IsNullOrHasNoValue(provisionForVoidHnd))
{
return(false);
}
IFCAnyHandle prodRepHnd = IFCAnyHandleUtil.GetInstanceAttribute(provisionForVoidHnd, "Representation");
if (IFCAnyHandleUtil.IsNullOrHasNoValue(prodRepHnd))
{
return(false);
}
IList <IFCAnyHandle> repHnds = IFCAnyHandleUtil.GetRepresentations(prodRepHnd);
foreach (IFCAnyHandle repHnd in repHnds)
{
string repId = IFCAnyHandleUtil.GetStringAttribute(repHnd, "RepresentationIdentifier");
if (String.Compare(repId, "Body", true) != 0)
{
continue;
}
string repType = IFCAnyHandleUtil.GetStringAttribute(repHnd, "RepresentationType");
if (String.Compare(repType, "SweptSolid", true) != 0)
{
return(false);
}
HashSet <IFCAnyHandle> repItemSet = IFCAnyHandleUtil.GetAggregateInstanceAttribute <HashSet <IFCAnyHandle> >(repHnd, "Items");
int numRepItems = repItemSet.Count;
if (numRepItems == 0)
{
return(false);
}
if (numRepItems == 1)
{
IFCAnyHandle repItemHnd = repItemSet.ElementAt(0);
if (!IFCAnyHandleUtil.IsSubTypeOf(repItemHnd, IFCEntityType.IfcExtrudedAreaSolid))
{
return(false);
}
IFCAnyHandle sweptAreaHnd = IFCAnyHandleUtil.GetInstanceAttribute(repItemHnd, "SweptArea");
if (IFCAnyHandleUtil.IsNullOrHasNoValue(sweptAreaHnd))
{
return(false);
}
m_CurrentProfileHandle = sweptAreaHnd;
if (IFCAnyHandleUtil.IsTypeOf(m_CurrentProfileHandle, IFCEntityType.IfcRectangleProfileDef))
{
m_Shape = IFCProvisionForVoidShapeType.Rectangle.ToString();
}
else if (IFCAnyHandleUtil.IsTypeOf(m_CurrentProfileHandle, IFCEntityType.IfcCircleProfileDef))
{
m_Shape = IFCProvisionForVoidShapeType.Round.ToString();
}
}
if (m_Shape == null)
{
m_Shape = IFCProvisionForVoidShapeType.Undefined.ToString();
m_CurrentProfileHandle = null;
}
m_CurrentElement = element;
return(true);
}
return(false);
}
/// <summary>
/// Calculates concealed value for a space.
/// </summary>
/// <param name="exporterIFC">The ExporterIFC object.</param>
/// <param name="extrusionCreationData">The IFCExtrusionCreationData.</param>
/// <param name="element">The element to calculate the value.</param>
/// <param name="elementType">The element type.</param>
/// <returns>True if the operation succeed, false otherwise.</returns>
public override bool Calculate(ExporterIFC exporterIFC, IFCExtrusionCreationData extrusionCreationData, Element element, ElementType elementType, EntryMap entryMap)
{
int?concealedCeiling = ParameterUtil.GetIntValueFromElementOrSymbol(element, entryMap.RevitParameterName);
if (!concealedCeiling.HasValue)
{
concealedCeiling = ParameterUtil.GetIntValueFromElementOrSymbol(element, entryMap.CompatibleRevitParameterName);
}
if (!concealedCeiling.HasValue)
{
return(false);
}
Concealed = concealedCeiling.GetValueOrDefault(0) != 0;
return(true);
}
/// <summary>
/// Calculates external value for an element.
/// </summary>
/// <param name="exporterIFC">The ExporterIFC object.</param>
/// <param name="extrusionCreationData">The IFCExtrusionCreationData.</param>
/// <param name="element">The element to calculate the value.</param>
/// <param name="elementType">The element type.</param>
/// <returns>True if the operation succeed, false otherwise.</returns>
public override bool Calculate(ExporterIFC exporterIFC, IFCExtrusionCreationData extrusionCreationData, Element element, ElementType elementType, EntryMap entryMap)
{
FabricParams fabricParams = null;
if (!ExporterCacheManager.FabricParamsCache.TryGetValue(element?.Id, out fabricParams))
{
return(false);
}
LongitudinalBarSpacing = fabricParams.LongitudinalBarSpacing;
return(true);
}
/// <summary>
/// Calculates total area for a roof
/// </summary>
/// <param name="exporterIFC">
/// The ExporterIFC object.
/// </param>
/// <param name="extrusionCreationData">
/// The IFCExtrusionCreationData.
/// </param>
/// <param name="element">
/// The element to calculate the value.
/// </param>
/// <param name="elementType">
/// The element type.
/// </param>
/// <returns>
/// True if the operation succeed, false otherwise.
/// </returns>
public override bool Calculate(ExporterIFC exporterIFC, IFCExtrusionCreationData extrusionCreationData, Element element, ElementType elementType, EntryMap entryMap)
{
if (ParameterUtil.GetDoubleValueFromElementOrSymbol(element, entryMap.RevitParameterName, out m_Area) == null)
{
ParameterUtil.GetDoubleValueFromElementOrSymbol(element, entryMap.CompatibleRevitParameterName, out m_Area);
}
if (m_Area > MathUtil.Eps() * MathUtil.Eps())
{
return(true);
}
m_Area = UnitUtil.ScaleArea(ExporterIFCUtils.ComputeRoofProjectedArea(element));
return(m_Area > MathUtil.Eps() * MathUtil.Eps());
}
/// <summary>
/// Calculates number of risers for a stair.
/// </summary>
/// <param name="exporterIFC">
/// The ExporterIFC object.
/// </param>
/// <param name="extrusionCreationData">
/// The IFCExtrusionCreationData.
/// </param>
/// <param name="element">
/// The element to calculate the value.
/// </param>
/// <param name="elementType">
/// The element type.
/// </param>
/// <returns>
/// True if the operation succeed, false otherwise.
/// </returns>
public override bool Calculate(ExporterIFC exporterIFC, IFCExtrusionCreationData extrusionCreationData, Element element, ElementType elementType, EntryMap entryMap)
{
bool valid = true;
// Get override from parameter
if (ParameterUtil.GetDoubleValueFromElementOrSymbol(element, entryMap.RevitParameterName, out m_WaistThickness) != null)
{
if (ParameterUtil.GetDoubleValueFromElementOrSymbol(element, entryMap.CompatibleRevitParameterName, out m_WaistThickness) != null)
{
m_WaistThickness = UnitUtil.ScaleArea(m_WaistThickness);
}
}
return(valid);
}
/// <summary>
/// Calculates the diameter of a provision for void.
/// </summary>
/// <param name="exporterIFC">The ExporterIFC object.</param>
/// <param name="extrusionCreationData">The IFCExtrusionCreationData.</param>
/// <param name="element">The element to calculate the value.</param>
/// <param name="elementType">The element type.</param>
/// <returns>
/// True if the operation succeed, false otherwise.
/// </returns>
public override bool Calculate(ExporterIFC exporterIFC, IFCExtrusionCreationData extrusionCreationData, Element element, ElementType elementType, EntryMap entryMap)
{
if (ParameterUtil.GetDoubleValueFromElementOrSymbol(element, entryMap.RevitParameterName, out m_Diameter) == null)
{
if (ParameterUtil.GetDoubleValueFromElementOrSymbol(element, entryMap.CompatibleRevitParameterName, out m_Diameter) == null)
{
ParameterUtil.GetDoubleValueFromElementOrSymbol(element, "IfcQtyDiameter", out m_Diameter);
}
}
m_Diameter = UnitUtil.ScaleLength(m_Diameter);
if (m_Diameter > MathUtil.Eps() * MathUtil.Eps())
{
return(true);
}
if (extrusionCreationData == null)
{
return(false);
}
// For ProvisionForVoid
ShapeCalculator shapeCalculator = ShapeCalculator.Instance;
if (shapeCalculator != null && shapeCalculator.GetCurrentElement() == element)
{
if (String.Compare(shapeCalculator.GetStringValue(), IFCProvisionForVoidShapeType.Round.ToString()) == 0)
{
m_Diameter = extrusionCreationData.ScaledOuterPerimeter / Math.PI;
if (m_Diameter > MathUtil.Eps())
{
return(true);
}
}
}
return(false);
}
/// <summary>
/// Calculates number of risers for a stair.
/// </summary>
/// <param name="exporterIFC">The ExporterIFC object.</param>
/// <param name="extrusionCreationData">The IFCExtrusionCreationData.</param>
/// <param name="element">The element to calculate the value.</param>
/// <param name="elementType">The element type.</param>
/// <returns>True if the operation succeed, false otherwise.</returns>
public override bool Calculate(ExporterIFC exporterIFC, IFCExtrusionCreationData extrusionCreationData, Element element, ElementType elementType, EntryMap entryMap)
{
bool valid = true;
if (StairsExporter.IsLegacyStairs(element))
{
double riserHeight, treadLength, treadLengthAtInnerSide, nosingLength, waistThickness = 0;
int numberOfTreads;
ExporterIFCUtils.GetLegacyStairsProperties(exporterIFC, element,
out m_NumberOfRisers, out numberOfTreads,
out riserHeight, out treadLength, out treadLengthAtInnerSide,
out nosingLength, out waistThickness);
}
else if (element is Stairs)
{
Stairs stairs = element as Stairs;
m_NumberOfRisers = stairs.ActualRisersNumber;
}
else if (element is StairsRun)
{
StairsRun stairsRun = element as StairsRun;
StairsRunType stairsRunType = stairsRun.Document.GetElement(stairsRun.GetTypeId()) as StairsRunType;
m_NumberOfRisers = stairsRun.ActualRisersNumber;
}
else
{
valid = false;
}
// Get override from parameter
int?noRiserOverride = ParameterUtil.GetIntValueFromElementOrSymbol(element, entryMap.RevitParameterName);
if (!noRiserOverride.HasValue)
{
noRiserOverride = ParameterUtil.GetIntValueFromElementOrSymbol(element, entryMap.CompatibleRevitParameterName);
}
if (noRiserOverride.HasValue)
{
m_NumberOfRisers = noRiserOverride.Value;
valid = true;
}
return(valid);
}
/// <summary>
/// Calculates span value for a beam.
/// </summary>
/// <param name="exporterIFC">
/// The ExporterIFC object.
/// </param>
/// <param name="extrusionCreationData">
/// The IFCExtrusionCreationData.
/// </param>
/// <param name="element">
/// The element to calculate the value.
/// </param>
/// <param name="elementType">
/// The element type.
/// </param>
/// <returns>
/// True if the operation succeed, false otherwise.
/// </returns>
public override bool Calculate(ExporterIFC exporterIFC, IFCExtrusionCreationData extrusionCreationData, Element element, ElementType elementType, EntryMap entryMap)
{
// Check the override first from "IfcSpan" parameter, if not overriden use the geometry data from extrusion
double spanVal;
if (ParameterUtil.GetDoubleValueFromElementOrSymbol(element, entryMap.RevitParameterName, out spanVal) == null)
{
if (ParameterUtil.GetDoubleValueFromElementOrSymbol(element, entryMap.CompatibleRevitParameterName, out spanVal) == null)
{
return(false);
}
}
spanVal = UnitUtil.ScaleLength(spanVal);
if (spanVal > MathUtil.Eps())
{
m_Span = spanVal;
return(true);
}
if (extrusionCreationData == null || MathUtil.IsAlmostZero(extrusionCreationData.ScaledLength))
{
return(false);
}
m_Span = extrusionCreationData.ScaledLength;
// No support, do nothing. Leave the Span to be the length of the entire beam
return(true);
}
/// <summary>
/// Calculates Roll value (Rotation angle) for a beam, column and member
/// </summary>
/// <param name="exporterIFC">
/// The ExporterIFC object.
/// </param>
/// <param name="extrusionCreationData">
/// The IFCExtrusionCreationData.
/// </param>
/// <param name="element">
/// The element to calculate the value.
/// </param>
/// <param name="elementType">
/// The element type.
/// </param>
/// <returns>
/// True if the operation succeed, false otherwise.
/// </returns>
public override bool Calculate(ExporterIFC exporterIFC, IFCExtrusionCreationData extrusionCreationData, Element element, ElementType elementType, EntryMap entryMap)
{
Parameter rollPar = element.get_Parameter(BuiltInParameter.STRUCTURAL_BEND_DIR_ANGLE);
if (rollPar != null)
{
double?roll = rollPar.AsDouble();
if (roll != null && roll.HasValue)
{
m_Roll = UnitUtil.ScaleAngle(roll.Value);
return(true);
}
}
// For other elements with ExtrusionData. Parameter will take precedence (override)
if (ParameterUtil.GetDoubleValueFromElementOrSymbol(element, entryMap.RevitParameterName, out m_Roll) == null)
{
ParameterUtil.GetDoubleValueFromElementOrSymbol(element, entryMap.CompatibleRevitParameterName, out m_Roll);
}
m_Roll = UnitUtil.ScaleAngle(m_Roll);
if (m_Roll > MathUtil.Eps())
{
return(true);
}
return(false);
}
public void TestEntryMap()
{
Serializer serializer = new Persister();
EntryMap example = serializer.read(EntryMap.class, ENTRY_MAP);
/// <summary>
/// Calculates shape parameter B for a rebar.
/// </summary>
/// <param name="exporterIFC">The ExporterIFC object.</param>
/// <param name="extrusionCreationData">The IFCExtrusionCreationData.</param>
/// <param name="element">The element to calculate the value.</param>
/// <param name="elementType">The element type.</param>
/// <returns>
/// True if the operation succeed, false otherwise.
/// </returns>
public override bool Calculate(ExporterIFC exporterIFC, IFCExtrusionCreationData extrusionCreationData, Element element, ElementType elementType, EntryMap entryMap)
{
if (element is Rebar)
{
Rebar rebar = element as Rebar;
if (rebar.CanBeMatchedWithMultipleShapes())
{
return(false); // In case of the Bent free form the parameter should be obtain from subelement. (It can have value for another bar in set and we don't want that value).
}
}
bool ret = ParameterUtil.GetDoubleValueFromElement(element, BuiltInParameterGroup.PG_GEOMETRY, "B", out m_ShapeParameterB) != null;
if (ret)
{
m_ShapeParameterB = UnitUtil.ScaleLength(m_ShapeParameterB);
}
return(ret);
}
/// <summary>
/// Calculates external value for an element.
/// </summary>
/// <param name="exporterIFC">The ExporterIFC object.</param>
/// <param name="extrusionCreationData">The IFCExtrusionCreationData.</param>
/// <param name="element">The element to calculate the value.</param>
/// <param name="elementType">The element type.</param>
/// <returns>True if the operation succeed, false otherwise.</returns>
public override bool Calculate(ExporterIFC exporterIFC, IFCExtrusionCreationData extrusionCreationData, Element element, ElementType elementType, EntryMap entryMap)
{
IsExternal = CategoryUtil.IsElementExternal(element);
return(true);
}
/// <summary>
/// Calculates number of risers for a stair.
/// </summary>
/// <param name="exporterIFC">
/// The ExporterIFC object.
/// </param>
/// <param name="extrusionCreationData">
/// The IFCExtrusionCreationData.
/// </param>
/// <param name="element">
/// The element to calculate the value.
/// </param>
/// <param name="elementType">
/// The element type.
/// </param>
/// <returns>
/// True if the operation succeed, false otherwise.
/// </returns>
public override bool Calculate(ExporterIFC exporterIFC, IFCExtrusionCreationData extrusionCreationData, Element element, ElementType elementType, EntryMap entryMap)
{
bool valid = true;
if (StairsExporter.IsLegacyStairs(element))
{
double riserHeight, treadLengthAtInnerSide, nosingLength, waistThickness = 0;
int numberOfRisers, numberOfTreads = 0;
ExporterIFCUtils.GetLegacyStairsProperties(exporterIFC, element,
out numberOfRisers, out numberOfTreads,
out riserHeight, out m_TreadLength, out treadLengthAtInnerSide,
out nosingLength, out waistThickness);
}
else if (element is Stairs)
{
Stairs stairs = element as Stairs;
m_TreadLength = UnitUtil.ScaleLength(stairs.ActualTreadDepth);
}
else if (element is StairsRun)
{
StairsRun stairsRun = element as StairsRun;
StairsRunType stairsRunType = stairsRun.Document.GetElement(stairsRun.GetTypeId()) as StairsRunType;
Stairs stairs = stairsRun.GetStairs();
m_TreadLength = UnitUtil.ScaleLength(stairs.ActualTreadDepth);
}
else
{
valid = false;
}
// Get override from parameter
double treadLengthOverride = 0.0;
if (ParameterUtil.GetDoubleValueFromElementOrSymbol(element, entryMap.RevitParameterName, out treadLengthOverride) != null ||
ParameterUtil.GetDoubleValueFromElementOrSymbol(element, entryMap.CompatibleRevitParameterName, out treadLengthOverride) != null)
{
m_TreadLength = UnitUtil.ScaleArea(treadLengthOverride);
}
return(valid);
}
/// <summary>
/// Calculates cross area.
/// </summary>
/// <param name="exporterIFC">
/// The ExporterIFC object.
/// </param>
/// <param name="extrusionCreationData">
/// The IFCExtrusionCreationData.
/// </param>
/// <param name="element">
/// The element to calculate the value.
/// </param>
/// <param name="elementType">
/// The element type.
/// </param>
/// <returns>
/// True if the operation succeed, false otherwise.
/// </returns>
public override bool Calculate(ExporterIFC exporterIFC, IFCExtrusionCreationData extrusionCreationData, Element element, ElementType elementType, EntryMap entryMap)
{
if (ParameterUtil.GetDoubleValueFromElementOrSymbol(element, entryMap.RevitParameterName, out m_Area) == null)
{
if (ParameterUtil.GetDoubleValueFromElementOrSymbol(element, entryMap.CompatibleRevitParameterName, out m_Area) == null)
{
ParameterUtil.GetDoubleValueFromElementOrSymbol(element, "IfcQtyGrossArea", out m_Area);
}
}
m_Area = UnitUtil.ScaleArea(m_Area);
if (m_Area > MathUtil.Eps() * MathUtil.Eps())
{
return(true);
}
if (extrusionCreationData == null)
{
return(false);
}
m_Area = extrusionCreationData.ScaledArea;
if (m_Area > MathUtil.Eps() * MathUtil.Eps())
{
return(true);
}
return(false);
}
/// <summary>
/// Calculates specific zones for a space.
/// </summary>
/// <param name="exporterIFC">The ExporterIFC object.</param>
/// <param name="extrusionCreationData">The IFCExtrusionCreationData.</param>
/// <param name="element">The element to calculate the value.</param>
/// <param name="elementType">The element type.</param>
/// <returns>True if the operation succeed, false otherwise.</returns>
public override bool Calculate(ExporterIFC exporterIFC, IFCExtrusionCreationData extrusionCreationData, Element element, ElementType elementType, EntryMap entryMap)
{
string basePropSpecZoneString = "Project Specific Zone";
int val = 0;
while (++val < 1000) // prevent infinite loop.
{
string propSpecZoneString;
if (val == 1)
{
propSpecZoneString = basePropSpecZoneString;
}
else
{
propSpecZoneString = basePropSpecZoneString + " " + val;
}
string value;
if ((ParameterUtil.GetStringValueFromElementOrSymbol(element, propSpecZoneString, out value) == null) ||
string.IsNullOrEmpty(value))
{
break;
}
m_SpecificZones.Add(value);
}
return(m_SpecificZones.Count > 0);
}
/// <summary>
/// Calculates perimeter for a space.
/// </summary>
/// <param name="exporterIFC">
/// The ExporterIFC object.
/// </param>
/// <param name="extrusionCreationData">
/// The IFCExtrusionCreationData.
/// </param>
/// <param name="element">
/// The element to calculate the value.
/// </param>
/// <param name="elementType">
/// The element type.
/// </param>
/// <returns>
/// True if the operation succeed, false otherwise.
/// </returns>
public override bool Calculate(ExporterIFC exporterIFC, IFCExtrusionCreationData extrusionCreationData, Element element, ElementType elementType, EntryMap entryMap)
{
if (ParameterUtil.GetDoubleValueFromElementOrSymbol(element, entryMap.RevitParameterName, out m_Perimeter) == null)
{
if (ParameterUtil.GetDoubleValueFromElementOrSymbol(element, entryMap.CompatibleRevitParameterName, out m_Perimeter) == null)
{
ParameterUtil.GetDoubleValueFromElementOrSymbol(element, "IfcQtyPerimeter", out m_Perimeter);
}
}
if (m_Perimeter > MathUtil.Eps())
{
return(true);
}
if (extrusionCreationData == null)
{
return(false);
}
m_Perimeter = extrusionCreationData.ScaledOuterPerimeter;
return(m_Perimeter > MathUtil.Eps());
}
/// <summary>
/// Calculates cross area.
/// </summary>
/// <param name="exporterIFC">
/// The ExporterIFC object.
/// </param>
/// <param name="extrusionCreationData">
/// The IFCExtrusionCreationData.
/// </param>
/// <param name="element">
/// The element to calculate the value.
/// </param>
/// <param name="elementType">
/// The element type.
/// </param>
/// <returns>
/// True if the operation succeed, false otherwise.
/// </returns>
public override bool Calculate(ExporterIFC exporterIFC, IFCExtrusionCreationData extrusionCreationData, Element element, ElementType elementType, EntryMap entryMap)
{
double lengthFromParam = 0;
if (ParameterUtil.GetDoubleValueFromElementOrSymbol(element, entryMap.RevitParameterName, out lengthFromParam) == null)
{
if (ParameterUtil.GetDoubleValueFromElementOrSymbol(element, entryMap.CompatibleRevitParameterName, out lengthFromParam) == null)
{
ParameterUtil.GetDoubleValueFromElementOrSymbol(element, "IfcQtyLength", out lengthFromParam);
}
}
m_Length = UnitUtil.ScaleLength(lengthFromParam);
// Check for Stair Run - Do special computation for the length
if (element is StairsRun)
{
StairsRun flight = element as StairsRun;
double flightLen = flight.GetStairsPath().GetExactLength();
flightLen = UnitUtil.ScaleLength(flightLen);
if (flightLen > MathUtil.Eps())
{
m_Length = flightLen;
return(true);
}
// consider override as specified in a parameter
else if (m_Length > MathUtil.Eps())
{
return(true);
}
// exit when none for StairsRun
else
{
return(false);
}
}
// For others
if (m_Length > MathUtil.Eps())
{
return(true);
}
if (extrusionCreationData == null)
{
if (ParameterUtil.GetDoubleValueFromElement(element, BuiltInParameter.EXTRUSION_LENGTH, out m_Length) != null)
{
m_Length = UnitUtil.ScaleLength(m_Length);
}
}
else
{
// For Slab, length is the major edge of the rectangle area profile (get it from ScaledWidth)
// Also for Stair support
IFCAnyHandle hnd = ExporterCacheManager.ElementToHandleCache.Find(element.Id);
if (IFCAnyHandleUtil.IsSubTypeOf(hnd, IFCEntityType.IfcSlab) || element.Category.BuiltInCategory == BuiltInCategory.OST_StairsStringerCarriage)
{
m_Length = extrusionCreationData.ScaledWidth;
}
else
{
m_Length = extrusionCreationData.ScaledLength;
}
}
if (m_Length > MathUtil.Eps())
{
return(true);
}
return(false);
}
public IEnumerable <string> EnumerateFiles() => EntryMap.Select(x => x.Key);
/// <summary>
/// Calculates temperature value for a space.
/// </summary>
/// <param name="exporterIFC">The ExporterIFC object.</param>
/// <param name="extrusionCreationData">The IFCExtrusionCreationData.</param>
/// <param name="element">The element to calculate the value.</param>
/// <param name="elementType">The element type.</param>
/// <returns>True if the operation succeed, false otherwise.</returns>
public override bool Calculate(ExporterIFC exporterIFC, IFCExtrusionCreationData extrusionCreationData, Element element, ElementType elementType, EntryMap entryMap)
{
if (ParameterUtil.GetDoubleValueFromElementOrSymbol(element, entryMap.RevitParameterName, out m_SpaceTemperatureSummer) != null ||
ParameterUtil.GetDoubleValueFromElementOrSymbol(element, entryMap.CompatibleRevitParameterName, out m_SpaceTemperatureSummer) != null)
{
return(true);
}
double maxValue = 0, minValue = 0;
if ((ParameterUtil.GetDoubleValueFromElementOrSymbol(element, entryMap.RevitParameterName + "Max", out maxValue) != null) &&
(ParameterUtil.GetDoubleValueFromElementOrSymbol(element, entryMap.RevitParameterName + "Min", out minValue) != null) ||
(ParameterUtil.GetDoubleValueFromElementOrSymbol(element, entryMap.CompatibleRevitParameterName + "Max", out maxValue) != null) &&
(ParameterUtil.GetDoubleValueFromElementOrSymbol(element, entryMap.CompatibleRevitParameterName + "Min", out minValue) != null))
{
m_SpaceTemperatureSummer = (maxValue + minValue) / 2.0;
return(true);
}
return(false);
}
/// <summary>
/// Calculates height for a railing
/// </summary>
/// <param name="exporterIFC">
/// The ExporterIFC object.
/// </param>
/// <param name="extrusionCreationData">
/// The IFCExtrusionCreationData.
/// </param>
/// <param name="element">
/// The element to calculate the value.
/// </param>
/// <param name="elementType">
/// The element type.
/// </param>
/// <returns>
/// True if the operation succeed, false otherwise.
/// </returns>
public override bool Calculate(ExporterIFC exporterIFC, IFCExtrusionCreationData extrusionCreationData, Element element, ElementType elementType, EntryMap entryMap)
{
if (element == null)
{
return(false);
}
// For Railing
RailingType railingType = element.Document.GetElement(element.GetTypeId()) as RailingType;
if (railingType != null)
{
m_Height = UnitUtil.ScaleLength(railingType.TopRailHeight);
return(true);
}
// For ProvisionForVoid
ShapeCalculator shapeCalculator = ShapeCalculator.Instance;
if (shapeCalculator != null && shapeCalculator.GetCurrentElement() == element)
{
if (String.Compare(shapeCalculator.GetStringValue(), IFCProvisionForVoidShapeType.Rectangle.ToString()) == 0)
{
IFCAnyHandle rectProfile = shapeCalculator.GetCurrentProfileHandle();
if (!IFCAnyHandleUtil.IsNullOrHasNoValue(rectProfile))
{
// This is already scaled.
double?height = IFCAnyHandleUtil.GetDoubleAttribute(rectProfile, "YDim");
m_Height = height.HasValue ? height.Value : 0.0;
if (m_Height > MathUtil.Eps())
{
return(true);
}
}
}
}
if (ParameterUtil.GetDoubleValueFromElementOrSymbol(element, entryMap.RevitParameterName, out m_Height) == null)
{
ParameterUtil.GetDoubleValueFromElementOrSymbol(element, entryMap.CompatibleRevitParameterName, out m_Height);
}
m_Height = UnitUtil.ScaleLength(m_Height);
if (m_Height > MathUtil.Eps())
{
return(true);
}
// For other elements
if (extrusionCreationData == null)
{
return(false);
}
m_Height = extrusionCreationData.ScaledHeight;
return(m_Height > MathUtil.Eps());
}
/// <summary>
/// Calculates external value for an element.
/// </summary>
/// <param name="exporterIFC">The ExporterIFC object.</param>
/// <param name="extrusionCreationData">The IFCExtrusionCreationData.</param>
/// <param name="element">The element to calculate the value.</param>
/// <param name="elementType">The element type.</param>
/// <returns>True if the operation succeed, false otherwise.</returns>
public override bool Calculate(ExporterIFC exporterIFC, IFCExtrusionCreationData extrusionCreationData, Element element, ElementType elementType, EntryMap entryMap)
{
FabricParams fabricParams = null;
if (!ExporterCacheManager.FabricParamsCache.TryGetValue(element?.Id, out fabricParams))
{
return(false);
}
TransverseBarNominalDiameter = fabricParams.TransverseBarNominalDiameter;
return(true);
}
/// <summary>
/// Calculates width for a slab.
/// </summary>
/// <param name="exporterIFC">
/// The ExporterIFC object.
/// </param>
/// <param name="extrusionCreationData">
/// The IFCExtrusionCreationData.
/// </param>
/// <param name="element">
/// The element to calculate the value.
/// </param>
/// <param name="elementType">
/// The element type.
/// </param>
/// <returns>
/// True if the operation succeed, false otherwise.
/// </returns>
public override bool Calculate(ExporterIFC exporterIFC, IFCExtrusionCreationData extrusionCreationData, Element element, ElementType elementType, EntryMap entryMap)
{
ShapeCalculator shapeCalculator = ShapeCalculator.Instance;
if (shapeCalculator != null && shapeCalculator.GetCurrentElement() == element)
{
if (String.Compare(shapeCalculator.GetStringValue(), IFCProvisionForVoidShapeType.Rectangle.ToString()) == 0)
{
IFCAnyHandle rectProfile = shapeCalculator.GetCurrentProfileHandle();
if (!IFCAnyHandleUtil.IsNullOrHasNoValue(rectProfile))
{
// This is already scaled.
double?width = IFCAnyHandleUtil.GetDoubleAttribute(rectProfile, "XDim");
m_Width = width.HasValue ? width.Value : 0.0;
if (m_Width > MathUtil.Eps())
{
return(true);
}
}
}
}
if (ParameterUtil.GetDoubleValueFromElementOrSymbol(element, entryMap.RevitParameterName, out m_Width) == null)
{
if (ParameterUtil.GetDoubleValueFromElementOrSymbol(element, entryMap.CompatibleRevitParameterName, out m_Width) == null)
{
ParameterUtil.GetDoubleValueFromElementOrSymbol(element, "IfcQtyWidth", out m_Width);
}
}
m_Width = UnitUtil.ScaleLength(m_Width);
if (m_Width > MathUtil.Eps())
{
return(true);
}
if (extrusionCreationData == null)
{
return(false);
}
// For Slab width is the lesser edge of the rectangle area profile (get it from ScaledHeight)
IFCAnyHandle hnd = ExporterCacheManager.ElementToHandleCache.Find(element.Id);
if (IFCAnyHandleUtil.IsSubTypeOf(hnd, IFCEntityType.IfcSlab))
{
m_Width = extrusionCreationData.ScaledHeight;
}
else
{
m_Width = extrusionCreationData.ScaledWidth;
}
return(m_Width > MathUtil.Eps());
}
/// <summary>
/// Calculates slope value.
/// </summary>
/// <param name="exporterIFC">The ExporterIFC object.</param>
/// <param name="extrusionCreationData">The IFCExtrusionCreationData.</param>
/// <param name="element">The element to calculate the value.</param>
/// <param name="elementType">The element type.</param>
/// <returns>True if the operation succeed, false otherwise.</returns>
public override bool Calculate(ExporterIFC exporterIFC, IFCExtrusionCreationData extrusionCreationData, Element element, ElementType elementType, EntryMap entryMap)
{
double slope = double.NaN;
// We may have an extrusionCreationData that doesn't have anything set. We will check this by seeing if there is a valid length set.
// This works for Beam
if (extrusionCreationData == null || MathUtil.IsAlmostZero(extrusionCreationData.ScaledLength))
{
// Try looking for parameters that we can calculate slope from.
double startParamHeight = 0.0;
double endParamHeight = 0.0;
double length = 0.0;
if ((ParameterUtil.GetDoubleValueFromElement(element, BuiltInParameter.STRUCTURAL_BEAM_END0_ELEVATION, out startParamHeight) != null) &&
(ParameterUtil.GetDoubleValueFromElement(element, BuiltInParameter.STRUCTURAL_BEAM_END1_ELEVATION, out endParamHeight) != null) &&
(ParameterUtil.GetDoubleValueFromElement(element, BuiltInParameter.INSTANCE_LENGTH_PARAM, out length) != null))
{
if (!MathUtil.IsAlmostZero(length))
{
double factor = Math.Abs(endParamHeight - startParamHeight) / length;
slope = UnitUtil.ScaleAngle(MathUtil.SafeAsin(factor));
if (!double.IsNaN(slope))
{
m_Slope = slope;
return(true);
}
}
}
}
// This works for Ramp/RampFlight
if (ParameterUtil.GetDoubleValueFromElement(element, BuiltInParameter.RAMP_ATTR_MIN_INV_SLOPE, out slope) != null)
{
m_Slope = UnitUtil.ScaleAngle(Math.Atan(slope));
return(true);
}
// For other elements with ExtrusionData. Parameter will take precedence (override)
if (ParameterUtil.GetDoubleValueFromElementOrSymbol(element, "Slope", out slope) != null)
{
m_Slope = UnitUtil.ScaleAngle(Math.Atan(slope));
return(true);
}
if (extrusionCreationData != null)
{
if (extrusionCreationData.Slope > MathUtil.Eps())
{
m_Slope = extrusionCreationData.Slope;
return(true);
}
else
{
// For any element that has axis, the slope will be computed based on the angle of the line vector
if (element.Location != null && element.Location is LocationCurve)
{
LocationCurve axis = element.Location as LocationCurve;
if (axis.Curve is Line)
{
Line axisCurve = axis.Curve as Line;
XYZ vectorProjOnXY = new XYZ(axisCurve.Direction.X, axisCurve.Direction.Y, 0.0).Normalize(); //Project the vector to XY plane
if (axisCurve.Direction.GetLength() > 0.0 && vectorProjOnXY.GetLength() > 0.0)
{
slope = UnitUtil.ScaleAngle(MathUtil.SafeAcos(axisCurve.Direction.DotProduct(vectorProjOnXY) / (axisCurve.Direction.GetLength() * vectorProjOnXY.GetLength())));
}
if (!double.IsNaN(slope))
{
m_Slope = slope;
return(true);
}
}
}
}
}
// The last attempt to compute the slope angle is to get the slope of the largest top facing face of the geometry
GeometryElement geomElem = element.get_Geometry(GeometryUtil.GetIFCExportGeometryOptions());
Face largestTopFace = null;
if (geomElem == null)
{
return(false);
}
foreach (GeometryObject geomObj in geomElem)
{
largestTopFace = GeometryUtil.GetLargestFaceInSolid(geomObj, new XYZ(0, 0, 1));
}
if (largestTopFace != null)
{
XYZ faceNormal = largestTopFace.ComputeNormal(new UV());
XYZ faceNormalProjXYPlane = new XYZ(faceNormal.X, faceNormal.Y, 0.0).Normalize();
slope = GeometryUtil.GetAngleOfFace(largestTopFace, faceNormalProjXYPlane);
if (!double.IsNaN(slope))
{
m_Slope = slope;
return(true);
}
}
return(false);
}
/// <summary>
/// Calculates cross area.
/// </summary>
/// <param name="exporterIFC">
/// The ExporterIFC object.
/// </param>
/// <param name="extrusionCreationData">
/// The IFCExtrusionCreationData.
/// </param>
/// <param name="element">
/// The element to calculate the value.
/// </param>
/// <param name="elementType">
/// The element type.
/// </param>
/// <returns>
/// True if the operation succeed, false otherwise.
/// </returns>
public override bool Calculate(ExporterIFC exporterIFC, IFCExtrusionCreationData extrusionCreationData, Element element, ElementType elementType, EntryMap entryMap)
{
double crossSectionArea = 0;
// 1. Check override parameter
if (ParameterUtil.GetDoubleValueFromElementOrSymbol(element, entryMap.RevitParameterName, out crossSectionArea) == null)
{
if (ParameterUtil.GetDoubleValueFromElementOrSymbol(element, entryMap.CompatibleRevitParameterName, out crossSectionArea) == null)
{
ParameterUtil.GetDoubleValueFromElementOrSymbol(element, "IfcQtyNetCrossSectionArea", out crossSectionArea);
}
}
m_Area = UnitUtil.ScaleArea(crossSectionArea);
if (m_Area > MathUtil.Eps() * MathUtil.Eps())
{
return(true);
}
// 2. try using extrusion data
if (extrusionCreationData == null)
{
return(false);
}
m_Area = extrusionCreationData.ScaledArea;
return(m_Area > MathUtil.Eps() * MathUtil.Eps());
}
