/// <summary>
/// Checks if element is external.
/// </summary>
/// <remarks>
/// An element is considered external if either:
/// <li> A special Yes/No parameter "IsExternal" is applied to it or its type and it's value is set to "yes".</li>
/// <li> The element itself has information about being an external element.</li>
/// All other elements are internal.
/// </remarks>
/// <param name="element">The element.</param>
/// <returns>True if the element is external, false otherwise.</returns>
public static bool IsElementExternal(Element element)
{
if (element == null)
{
return(false);
}
Document document = element.Document;
// Look for a parameter "IsExternal", potentially localized.
{
ElementId elementId = element.Id;
bool?maybeIsExternal = null;
if (!ExporterCacheManager.IsExternalParameterValueCache.TryGetValue(elementId, out maybeIsExternal))
{
int intIsExternal = 0;
string localExternalParamName = PropertySetEntryUtil.GetLocalizedIsExternal(ExporterCacheManager.LanguageType);
if ((localExternalParamName != null) && (ParameterUtil.GetIntValueFromElementOrSymbol(element, localExternalParamName, out intIsExternal) != null))
{
maybeIsExternal = (intIsExternal != 0);
}
if (!maybeIsExternal.HasValue && (ExporterCacheManager.LanguageType != LanguageType.English_USA))
{
string externalParamName = PropertySetEntryUtil.GetLocalizedIsExternal(LanguageType.English_USA);
if (ParameterUtil.GetIntValueFromElementOrSymbol(element, externalParamName, out intIsExternal) != null)
{
maybeIsExternal = (intIsExternal != 0);
}
}
ExporterCacheManager.IsExternalParameterValueCache.Add(new KeyValuePair <ElementId, bool?>(elementId, maybeIsExternal));
}
if (maybeIsExternal.HasValue)
{
return(maybeIsExternal.Value);
}
}
// Specific element types that know if they are external or not
// Categories are used, and not types, to also support in-place families
// Roofs are always external
ElementId categoryId = element.Category.Id;
if (categoryId == new ElementId(BuiltInCategory.OST_Roofs) ||
categoryId == new ElementId(BuiltInCategory.OST_MassExteriorWall))
{
return(true);
}
// Mass interior walls are always internal
if (categoryId == new ElementId(BuiltInCategory.OST_MassInteriorWall))
{
return(false);
}
// Wall types have the function parameter
if (element is Wall)
{
ElementType wallType = document.GetElement(element.GetTypeId()) as ElementType;
int wallFunction;
if (ParameterUtil.GetIntValueFromElement(wallType, BuiltInParameter.FUNCTION_PARAM, out wallFunction) != null)
{
return(wallFunction != ((int)WallFunction.Interior));
}
}
// Family instances may be hosted on an external element
if (element is FamilyInstance)
{
FamilyInstance familyInstance = (FamilyInstance)element;
Element familyInstanceHost = familyInstance.Host;
if (familyInstanceHost == null)
{
Reference familyInstanceHostReference = familyInstance.HostFace;
if (familyInstanceHostReference != null)
{
familyInstanceHost = document.GetElement(familyInstanceHostReference);
}
}
if (familyInstanceHost != null)
{
return(IsElementExternal(familyInstanceHost));
}
}
return(false);
}
/// <summary>
/// Clear all caches contained in this manager.
/// </summary>
public static void Clear()
{
if (m_AllocatedGeometryObjectCache != null)
{
m_AllocatedGeometryObjectCache.DisposeCache();
}
ParameterUtil.ClearParameterCache();
m_AllocatedGeometryObjectCache = null;
m_AreaSchemeCache = null;
m_AssemblyInstanceCache = null;
m_BeamSystemCache = null;
m_CategoryClassNameCache = null;
m_CategoryTypeCache = null;
m_CeilingSpaceRelCache = null;
m_ClassificationCache = null;
m_ClassificationLocationCache = null;
m_ConditionalPropertySetsForTypeCache = null;
m_ContainmentCache = null;
m_CurveAnnotationCache = null;
m_DefaultCartesianTransformationOperator3D = null;
m_DummyHostCache = null;
m_ElementToHandleCache = null;
m_ElementsInAssembliesCache = null;
m_ExportOptionsCache = null;
m_FabricAreaHandleCache = null;
m_GridCache = null;
m_GroupCache = null;
m_GroupElementGeometryCache = null;
m_HandleToElementCache = null;
m_HostPartsCache = null;
m_IsExternalParameterValueCache = null;
m_LevelInfoCache = null;
m_MaterialIdToStyleHandleCache = null;
m_MaterialLayerRelationsCache = null;
m_MaterialLayerSetCache = null;
m_MaterialHandleCache = null;
m_MaterialRelationsCache = null;
m_MEPCache = null;
m_ParameterCache = null;
m_PartExportedCache = null;
m_PresentationLayerSetCache = null;
m_PresentationStyleCache = null;
m_PropertyInfoCache = null;
m_PropertyMapCache = null;
m_PropertySetsForTypeCache = null;
m_RailingCache = null;
m_RailingSubElementCache = null;
m_SpaceBoundaryCache = null;
m_SpaceOccupantInfoCache = null;
m_SpatialElementHandleCache = null;
m_StairRampContainerInfoCache = null;
m_SystemsCache = null;
m_TrussCache = null;
m_TypeObjectsCache = null;
m_TypePropertyInfoCache = null;
m_TypeRelationsCache = null;
m_ViewScheduleElementCache = null;
m_WallConnectionDataCache = null;
m_WallTypeCache = null;
m_UnitsCache = null;
m_ZoneCache = null;
m_ZoneInfoCache = null;
}
/// <summary>
/// Gets export type for an element.
/// </summary>
/// <param name="exporterIFC">
/// The ExporterIFC object.
/// </param>
/// <param name="element">
/// The element.
/// </param>
/// <param name="enumTypeValue">
/// The output string value represents the enum type.
/// </param>
/// <returns>
/// The IFCExportType.
/// </returns>
public static IFCExportType GetExportType(ExporterIFC exporterIFC, Element element,
out string enumTypeValue)
{
enumTypeValue = "";
IFCExportType exportType = IFCExportType.DontExport;
// Get potential override value first.
{
string symbolClassName;
string exportAsEntity = "IFCExportAs";
string exportAsType = "IFCExportType";
ParameterUtil.GetStringValueFromElementOrSymbol(element, exportAsEntity, out symbolClassName);
ParameterUtil.GetStringValueFromElementOrSymbol(element, exportAsType, out enumTypeValue);
if (!String.IsNullOrEmpty(symbolClassName))
{
exportType = ElementFilteringUtil.GetExportTypeFromClassName(symbolClassName);
if (exportType != IFCExportType.DontExport)
{
return(exportType);
}
}
}
Category category = element.Category;
if (category == null)
{
return(IFCExportType.DontExport);
}
ElementId categoryId = category.Id;
string ifcClassName = ExporterIFCUtils.GetIFCClassName(element, exporterIFC);
if (ifcClassName != "")
{
enumTypeValue = ExporterIFCUtils.GetIFCType(element, exporterIFC);
// if using name, override category id if match is found.
if (!ifcClassName.Equals("Default", StringComparison.OrdinalIgnoreCase))
{
exportType = ElementFilteringUtil.GetExportTypeFromClassName(ifcClassName);
}
}
// if not set, fall back on category id.
if (exportType == IFCExportType.DontExport)
{
//bool exportSeparately = true;
exportType = ElementFilteringUtil.GetExportTypeFromCategoryId(categoryId, out enumTypeValue /*, out bool exportSeparately*/);
}
// if not set, fall back on symbol functions.
// allow override of IfcBuildingElementProxy.
if ((exportType == IFCExportType.DontExport) || (exportType == IFCExportType.ExportBuildingElementProxy))
{
// TODO: add isColumn.
//if (familySymbol.IsColumn())
//exportType = IFCExportType.ExportColumnType;
//else
FamilyInstance familyInstance = element as FamilyInstance;
if (familyInstance != null)
{
switch (familyInstance.StructuralType)
{
case Autodesk.Revit.DB.Structure.StructuralType.Beam:
exportType = IFCExportType.ExportBeam;
break;
case Autodesk.Revit.DB.Structure.StructuralType.Footing:
exportType = IFCExportType.ExportFooting;
break;
}
}
}
return(exportType);
}
/// <summary>
/// Creates window panel position.
/// </summary>
/// <param name="exporterIFC">
/// The ExporterIFC object.
/// </param>
/// <param name="familyInstance">
/// The family instance of a window.
/// </param>
/// <param name="description">
/// The description.
/// </param>
/// <returns>
/// The handle created.
/// </returns>
public static IFCAnyHandle CreateWindowLiningProperties(ExporterIFC exporterIFC,
Element familyInstance, string description)
{
IFCFile file = exporterIFC.GetFile();
IFCAnyHandle ownerHistory = exporterIFC.GetOwnerHistoryHandle();
double?liningDepthOpt = null;
double?liningThicknessOpt = null;
double?transomThicknessOpt = null;
double?mullionThicknessOpt = null;
double?firstTransomOffsetOpt = null;
double?secondTransomOffsetOpt = null;
double?firstMullionOffsetOpt = null;
double?secondMullionOffsetOpt = null;
double value1 = 0.0;
double value2 = 0.0;
// both of these must be defined (or not defined)
if (ParameterUtil.GetDoubleValueFromElementOrSymbol(familyInstance, "LiningDepth", out value1) &&
ParameterUtil.GetDoubleValueFromElementOrSymbol(familyInstance, "LiningThickness", out value2))
{
liningDepthOpt = value1;
liningThicknessOpt = value2;
}
if (ParameterUtil.GetDoubleValueFromElementOrSymbol(familyInstance, "TransomThickness", out value1))
{
transomThicknessOpt = value1;
}
if (ParameterUtil.GetDoubleValueFromElementOrSymbol(familyInstance, "FirstTransomOffset", out value1))
{
firstTransomOffsetOpt = value1;
}
if (ParameterUtil.GetDoubleValueFromElementOrSymbol(familyInstance, "SecondTransomOffset", out value1))
{
secondTransomOffsetOpt = value1;
}
if (ParameterUtil.GetDoubleValueFromElementOrSymbol(familyInstance, "MullionThickness", out value1))
{
mullionThicknessOpt = value1;
}
if (ParameterUtil.GetDoubleValueFromElementOrSymbol(familyInstance, "FirstMullionOffset", out value1))
{
firstMullionOffsetOpt = value1;
}
if (ParameterUtil.GetDoubleValueFromElementOrSymbol(familyInstance, "SecondMullionOffset", out value1))
{
secondMullionOffsetOpt = value1;
}
string windowLiningGUID = ExporterIFCUtils.CreateGUID();
string windowLiningName = exporterIFC.GetName();
return(IFCInstanceExporter.CreateWindowLiningProperties(file, windowLiningGUID, ownerHistory,
windowLiningName, description, liningDepthOpt, liningThicknessOpt, transomThicknessOpt, mullionThicknessOpt,
firstTransomOffsetOpt, secondTransomOffsetOpt, firstMullionOffsetOpt, secondMullionOffsetOpt, null));
}
/// <summary>
/// Gets window panel operation.
/// </summary>
/// <param name="initialValue">
/// The initial value.
/// </param>
/// <param name="element">
/// The window element.
/// </param>
/// <param name="number">
/// The number of panel operation.
/// </param>
/// <returns>
/// The string represents the window panel operation.
/// </returns>
public static IFCWindowPanelOperation GetIFCWindowPanelOperation(string initialValue, Element element, int number)
{
string currPanelName = "PanelOperation" + number.ToString();
string value;
if (!ParameterUtil.GetStringValueFromElementOrSymbol(element, currPanelName, out value))
{
value = initialValue;
}
if (value == "")
{
return(IFCWindowPanelOperation.NotDefined);
}
else if (NamingUtil.IsEqualIgnoringCaseSpacesAndUnderscores(value, "SideHungRightHand"))
{
return(IFCWindowPanelOperation.SideHungRightHand);
}
else if (NamingUtil.IsEqualIgnoringCaseSpacesAndUnderscores(value, "SideHungLeftHand"))
{
return(IFCWindowPanelOperation.SideHungLeftHand);
}
else if (NamingUtil.IsEqualIgnoringCaseSpacesAndUnderscores(value, "TiltAndTurnRightHand"))
{
return(IFCWindowPanelOperation.TiltAndTurnRightHand);
}
else if (NamingUtil.IsEqualIgnoringCaseSpacesAndUnderscores(value, "TiltAndTurnLeftHand"))
{
return(IFCWindowPanelOperation.TiltAndTurnLeftHand);
}
else if (NamingUtil.IsEqualIgnoringCaseSpacesAndUnderscores(value, "TopHung"))
{
return(IFCWindowPanelOperation.TopHung);
}
else if (NamingUtil.IsEqualIgnoringCaseSpacesAndUnderscores(value, "BottomHung"))
{
return(IFCWindowPanelOperation.BottomHung);
}
else if (NamingUtil.IsEqualIgnoringCaseSpacesAndUnderscores(value, "PivotHorizontal"))
{
return(IFCWindowPanelOperation.PivotHorizontal);
}
else if (NamingUtil.IsEqualIgnoringCaseSpacesAndUnderscores(value, "PivotVertical"))
{
return(IFCWindowPanelOperation.PivotVertical);
}
else if (NamingUtil.IsEqualIgnoringCaseSpacesAndUnderscores(value, "SlidingHorizontal"))
{
return(IFCWindowPanelOperation.SlidingHorizontal);
}
else if (NamingUtil.IsEqualIgnoringCaseSpacesAndUnderscores(value, "SlidingVertical"))
{
return(IFCWindowPanelOperation.SlidingVertical);
}
else if (NamingUtil.IsEqualIgnoringCaseSpacesAndUnderscores(value, "RemovableCasement"))
{
return(IFCWindowPanelOperation.RemovableCasement);
}
else if (NamingUtil.IsEqualIgnoringCaseSpacesAndUnderscores(value, "FixedCasement"))
{
return(IFCWindowPanelOperation.FixedCasement);
}
else if (NamingUtil.IsEqualIgnoringCaseSpacesAndUnderscores(value, "OtherOperation"))
{
return(IFCWindowPanelOperation.OtherOperation);
}
return(IFCWindowPanelOperation.NotDefined);
}
/// <summary>
/// Creates door lining properties.
/// </summary>
/// <param name="exporterIFC">
/// The ExporterIFC object.
/// </param>
/// <param name="familyInstance">
/// The family instance of a door.
/// </param>
/// <returns>
/// The handle created.
/// </returns>
public static IFCAnyHandle CreateDoorLiningProperties(ExporterIFC exporterIFC, Element familyInstance)
{
IFCFile file = exporterIFC.GetFile();
IFCAnyHandle ownerHistory = exporterIFC.GetOwnerHistoryHandle();
double?liningDepthOpt = null;
double?liningThicknessOpt = null;
double?thresholdDepthOpt = null;
double?thresholdThicknessOpt = null;
double?transomThicknessOpt = null;
double?transomOffsetOpt = null;
double?liningOffsetOpt = null;
double?thresholdOffsetOpt = null;
double?casingThicknessOpt = null;
double?casingDepthOpt = null;
double value1, value2;
// both of these must be defined, or not defined - if only one is defined, we ignore the values.
if (ParameterUtil.GetPositiveDoubleValueFromElementOrSymbol(familyInstance, "LiningDepth", out value1))
{
if (ParameterUtil.GetPositiveDoubleValueFromElementOrSymbol(familyInstance, "LiningThickness", out value2))
{
liningDepthOpt = value1;
liningThicknessOpt = value2;
}
}
if (ParameterUtil.GetDoubleValueFromElementOrSymbol(familyInstance, "LiningOffset", out value1))
{
liningOffsetOpt = value1;
}
// both of these must be defined, or not defined - if only one is defined, we ignore the values.
if (ParameterUtil.GetPositiveDoubleValueFromElementOrSymbol(familyInstance, "ThresholdDepth", out value1))
{
if (ParameterUtil.GetPositiveDoubleValueFromElementOrSymbol(familyInstance, "ThresholdThickness", out value2))
{
thresholdDepthOpt = value1;
thresholdThicknessOpt = value2;
}
}
if (ParameterUtil.GetDoubleValueFromElementOrSymbol(familyInstance, "ThreshholdOffset", out value1))
{
liningOffsetOpt = value1;
}
// both of these must be defined, or not defined - if only one is defined, we ignore the values.
if (ParameterUtil.GetDoubleValueFromElementOrSymbol(familyInstance, "TransomOffset", out value1))
{
if (ParameterUtil.GetPositiveDoubleValueFromElementOrSymbol(familyInstance, "TransomThickness", out value2))
{
transomOffsetOpt = value1;
transomThicknessOpt = value2;
}
}
// both of these must be defined, or not defined - if only one is defined, we ignore the values.
if (ParameterUtil.GetPositiveDoubleValueFromElementOrSymbol(familyInstance, "CasingDepth", out value1))
{
if (ParameterUtil.GetPositiveDoubleValueFromElementOrSymbol(familyInstance, "CasingThickness", out value2))
{
casingDepthOpt = value1;
casingThicknessOpt = value2;
}
}
string doorLiningGUID = ExporterIFCUtils.CreateSubElementGUID(familyInstance, (int)IFCDoorSubElements.DoorLining);
string doorLiningName = exporterIFC.GetName();
return(IFCInstanceExporter.CreateDoorLiningProperties(file, doorLiningGUID, ownerHistory,
doorLiningName, null, liningDepthOpt, liningThicknessOpt, thresholdDepthOpt, thresholdThicknessOpt,
transomThicknessOpt, transomOffsetOpt, liningOffsetOpt, thresholdOffsetOpt, casingThicknessOpt,
casingDepthOpt, null));
}
/// <summary>
/// Creates door panel properties.
/// </summary>
/// <param name="exporterIFC">
/// The ExporterIFC object.
/// </param>
/// <param name="doorWindowInfo">
/// The IFCDoorWindowInfo object.
/// </param>
/// <param name="familyInstance">
/// The family instance of a door.
/// </param>
/// <returns>
/// The list of handles created.
/// </returns>
public static IList <IFCAnyHandle> CreateDoorPanelProperties(ExporterIFC exporterIFC,
IFCDoorWindowInfo doorWindowInfo, Element familyInstance)
{
IFCFile file = exporterIFC.GetFile();
IFCAnyHandle ownerHistory = exporterIFC.GetOwnerHistoryHandle();
IList <IFCAnyHandle> doorPanels = new List <IFCAnyHandle>();
IList <double?> panelDepthList = new List <double?>();
IList <double?> panelWidthList = new List <double?>();
IList <IFCDoorPanelOperation> panelOperationList = new List <IFCDoorPanelOperation>();
IList <IFCDoorPanelPosition> panelPositionList = new List <IFCDoorPanelPosition>();
int panelNumber = 1;
const int maxPanels = 64; // arbitrary large number to prevent infinite loops.
for (; panelNumber < maxPanels; panelNumber++)
{
string panelDepthCurrString = "PanelDepth" + panelNumber.ToString();
string panelWidthCurrString = "PanelWidth" + panelNumber.ToString();
// We will always have at least one panel definition as long as the panelOperation is not
// NotDefined.
panelOperationList.Add(GetPanelOperationFromDoorStyleOperation(doorWindowInfo.DoorOperationType));
// If the panel operation is defined we'll allow no panel position for the 1st panel.
IFCDoorPanelPosition?panelPosition = GetIFCDoorPanelPosition("", familyInstance, panelNumber);
if (panelPosition == null)
{
if (panelNumber == 1)
{
panelPosition = GetIFCDoorPanelPosition("", familyInstance, -1);
}
if ((panelPosition == null) && (panelNumber > 1))
{
panelPositionList.Add(IFCDoorPanelPosition.NotDefined);
break;
}
}
if (doorWindowInfo.IsFlippedInX ^ doorWindowInfo.IsFlippedInY)
{
panelPosition = ReverseDoorPanelPosition(panelPosition);
}
panelPositionList.Add(panelPosition != null ? (IFCDoorPanelPosition)panelPosition : IFCDoorPanelPosition.NotDefined);
double value1 = 0.0, value2 = 0.0;
bool foundDepth = ParameterUtil.GetPositiveDoubleValueFromElementOrSymbol(familyInstance, panelDepthCurrString, out value1);
if (!foundDepth && (panelNumber == 1))
{
foundDepth = ParameterUtil.GetPositiveDoubleValueFromElementOrSymbol(familyInstance, "PanelDepth", out value1);
}
bool foundWidth = ParameterUtil.GetPositiveDoubleValueFromElementOrSymbol(familyInstance, panelWidthCurrString, out value2);
if (!foundWidth && (panelNumber == 1))
{
foundWidth = ParameterUtil.GetPositiveDoubleValueFromElementOrSymbol(familyInstance, "PanelWidth", out value2);
}
if (foundDepth && foundWidth)
{
panelDepthList.Add(value1);
panelWidthList.Add(value2);
}
else
{
panelDepthList.Add(null);
panelWidthList.Add(null);
}
}
// calculate panelWidths
double totalPanelWidth = 0.0;
for (int panelIndex = 0; (panelIndex < panelNumber - 1); panelIndex++)
{
if (panelDepthList[panelIndex] == null || MathUtil.IsAlmostZero((double)panelDepthList[panelIndex]) ||
panelWidthList[panelIndex] == null || MathUtil.IsAlmostZero((double)panelWidthList[panelIndex]))
{
totalPanelWidth = 0.0;
break;
}
totalPanelWidth += (double)panelWidthList[panelIndex];
}
if (!MathUtil.IsAlmostZero(totalPanelWidth))
{
for (int panelIndex = 0; (panelIndex < panelNumber - 1); panelIndex++)
{
double?currentPanelWidth = null;
if (panelWidthList[panelIndex].HasValue)
{
currentPanelWidth = (double)panelWidthList[panelIndex] / totalPanelWidth;
}
string doorPanelGUID = ExporterIFCUtils.CreateGUID();
string doorPanelName = exporterIFC.GetName();
IFCAnyHandle doorPanel = IFCInstanceExporter.CreateDoorPanelProperties(file, doorPanelGUID, ownerHistory,
doorPanelName, null, panelDepthList[panelIndex], panelOperationList[panelIndex],
currentPanelWidth, panelPositionList[panelIndex], null);
doorPanels.Add(doorPanel);
}
}
return(doorPanels);
}
