/// <summary>
/// Creates or populates Revit element params based on the information contained in this class.
/// </summary>
/// <param name="doc">The document.</param>
/// <param name="element">The element.</param>
protected override void CreateParametersInternal(Document doc, Element element)
{
base.CreateParametersInternal(doc, element);
if (element != null)
{
Category category = IFCPropertySet.GetCategoryForParameterIfValid(element, Id);
// Set "Tag" parameter.
string ifcTag = Tag;
if (!string.IsNullOrWhiteSpace(ifcTag))
{
IFCPropertySet.AddParameterString(doc, element, category, "IfcTag", ifcTag, Id);
}
IFCFeatureElementSubtraction ifcFeatureElementSubtraction = FillsOpening;
if (ifcFeatureElementSubtraction != null)
{
IFCElement ifcElement = ifcFeatureElementSubtraction.VoidsElement;
if (ifcElement != null)
{
string ifcContainerName = ifcElement.Name;
IFCPropertySet.AddParameterString(doc, element, category, "IfcContainedInHost", ifcContainerName, Id);
}
}
// Create two parameters for each port: one for name, and one for GUID.
// Note that Ports will never be null, as it is initialized the first time it is accessed.
int numPorts = 0;
foreach (IFCPort port in Ports)
{
string name = port.Name;
string guid = port.GlobalId;
if (!string.IsNullOrWhiteSpace(name))
{
string parameterName = "IfcElement HasPorts Name " + ((numPorts == 0) ? "" : (numPorts + 1).ToString());
IFCPropertySet.AddParameterString(doc, element, category, parameterName, name, Id);
}
if (!string.IsNullOrWhiteSpace(guid))
{
string parameterName = "IfcElement HasPorts IfcGUID " + ((numPorts == 0) ? "" : (numPorts + 1).ToString());
IFCPropertySet.AddParameterString(doc, element, category, parameterName, guid, Id);
}
numPorts++;
}
}
}
/// <summary>
/// Creates or populates Revit element params based on the information contained in this class.
/// </summary>
/// <param name="doc">The document.</param>
/// <param name="element">The element.</param>
protected override void CreateParametersInternal(Document doc, Element element)
{
base.CreateParametersInternal(doc, element);
if (element != null)
{
// Set "Tag" parameter.
string ifcTag = Tag;
if (!string.IsNullOrWhiteSpace(ifcTag))
{
IFCPropertySet.AddParameterString(doc, element, "IfcTag", ifcTag, Id);
}
}
}
/// <summary>
/// Creates or populates Revit element params based on the information contained in this class.
/// </summary>
/// <param name="doc">The document.</param>
/// <param name="element">The element.</param>
protected override void CreateParametersInternal(Document doc, Element element)
{
base.CreateParametersInternal(doc, element);
if (element != null)
{
// Set "ObjectTypeOverride" parameter.
string objectTypeOverride = ObjectType;
if (!string.IsNullOrWhiteSpace(objectTypeOverride))
{
IFCPropertySet.AddParameterString(doc, element, "ObjectTypeOverride", objectTypeOverride, Id);
}
}
}
/// <summary>
/// Creates or populates Revit element params based on the information contained in this class.
/// </summary>
/// <param name="doc">The document.</param>
/// <param name="element">The element.</param>
protected override void CreateParametersInternal(Document doc, Element element)
{
base.CreateParametersInternal(doc, element);
// TODO: Set the value in ProjectInfo if element is not created.
if (element != null)
{
// Set "ObjectTypeOverride" parameter.
string longName = LongName;
if (!string.IsNullOrWhiteSpace(longName))
{
IFCPropertySet.AddParameterString(doc, element, "LongNameOverride", longName, Id);
}
}
}
/// <summary>
/// Creates or populates Revit element params based on the information contained in this class.
/// </summary>
/// <param name="doc">The document.</param>
/// <param name="element">The element.</param>
protected override void CreateParametersInternal(Document doc, Element element)
{
base.CreateParametersInternal(doc, element);
if (element != null)
{
Category category = IFCPropertySet.GetCategoryForParameterIfValid(element, Id);
if (category != null)
{
Importer.TheProcessor.SetStringParameter(element, Id, BuiltInParameter.DOOR_OPERATION_TYPE, OperationType.ToString(), false);
Importer.TheProcessor.SetStringParameter(element, Id, BuiltInParameter.DOOR_CONSTRUCTION_TYPE, ConstructionType.ToString(), false);
IFCPropertySet.AddParameterString(doc, element, category, this, "IfcOperationType", OperationType.ToString(), Id);
IFCPropertySet.AddParameterString(doc, element, category, this, "IfcConstructionType", ConstructionType.ToString(), Id);
}
}
}
/// <summary>
/// Creates or populates Revit element params based on the information contained in this class.
/// </summary>
/// <param name="doc">The document.</param>
/// <param name="element">The element.</param>
protected override void CreateParametersInternal(Document doc, Element element)
{
base.CreateParametersInternal(doc, element);
string parameterName = "LandTitleNumber";
if (element == null)
{
element = doc.ProjectInformation;
parameterName = "Site " + parameterName;
}
if (element != null)
{
string landTitleNumber = LandTitleNumber;
if (!string.IsNullOrWhiteSpace(landTitleNumber))
{
IFCPropertySet.AddParameterString(doc, element, parameterName, landTitleNumber, Id);
}
}
}
/// <summary>
/// Creates or populates Revit element params based on the information contained in this class.
/// </summary>
/// <param name="doc">The document.</param>
/// <param name="element">The element.</param>
protected override void CreateParametersInternal(Document doc, Element element)
{
base.CreateParametersInternal(doc, element);
string parameterName = "LandTitleNumber";
// TODO: move this to new shared parameter names override function.
if (element is ProjectInfo)
{
parameterName = "IfcSite " + parameterName;
}
if (element != null)
{
string landTitleNumber = LandTitleNumber;
if (!string.IsNullOrWhiteSpace(landTitleNumber))
{
IFCPropertySet.AddParameterString(doc, element, parameterName, landTitleNumber, Id);
}
}
}
/// <summary>
/// Creates or populates Revit element params based on the information contained in this class.
/// </summary>
/// <param name="doc">The document.</param>
/// <param name="element">The element.</param>
protected override void CreateParametersInternal(Document doc, Element element)
{
base.CreateParametersInternal(doc, element);
if (element != null)
{
Category category = IFCPropertySet.GetCategoryForParameterIfValid(element, Id);
// Set "IfcPresentationLayer" parameter.
string ifcPresentationLayer = null;
foreach (string currLayer in PresentationLayerNames)
{
if (string.IsNullOrWhiteSpace(currLayer))
{
continue;
}
if (ifcPresentationLayer == null)
{
ifcPresentationLayer = currLayer;
}
else
{
ifcPresentationLayer += "; " + currLayer;
}
}
if (ifcPresentationLayer != null)
{
IFCPropertySet.AddParameterString(doc, element, category, this, "IfcPresentationLayer", ifcPresentationLayer, Id);
}
// Set the container name of the element.
string containerName = ContainingStructure?.Name;
if (containerName != null)
{
IFCPropertySet.AddParameterString(doc, element, category, this, "IfcSpatialContainer", containerName, Id);
IFCPropertySet.AddParameterString(doc, element, category, this, "IfcSpatialContainer GUID", ContainingStructure.GlobalId, Id);
}
}
}
/// <summary>
/// Creates or populates Revit element params based on the information contained in this class.
/// </summary>
/// <param name="doc">The document.</param>
/// <param name="element">The element.</param>
protected override void CreateParametersInternal(Document doc, Element element)
{
base.CreateParametersInternal(doc, element);
if (element != null)
{
Parameter operationTypeParameter = element.get_Parameter(BuiltInParameter.DOOR_OPERATION_TYPE);
if (operationTypeParameter != null)
{
operationTypeParameter.Set(OperationType.ToString());
}
IFCPropertySet.AddParameterString(doc, element, "IfcOperationType", OperationType.ToString(), Id);
Parameter constructionTypeParameter = element.get_Parameter(BuiltInParameter.DOOR_CONSTRUCTION_TYPE);
if (constructionTypeParameter != null)
{
constructionTypeParameter.Set(ConstructionType.ToString());
}
IFCPropertySet.AddParameterString(doc, element, "IfcConstructionType", ConstructionType.ToString(), Id);
}
}
/// <summary>
/// Creates or populates Revit element params based on the information contained in this class.
/// </summary>
/// <param name="doc">The document.</param>
/// <param name="element">The element.</param>
protected override void CreateParametersInternal(Document doc, Element element)
{
base.CreateParametersInternal(doc, element);
if (element != null)
{
// Set "ObjectTypeOverride" parameter.
string longName = LongName;
if (!string.IsNullOrWhiteSpace(longName))
{
string parameterName = "LongNameOverride";
if (element is ProjectInfo)
{
parameterName = EntityType.ToString() + " " + parameterName;
}
IFCPropertySet.AddParameterString(doc, element, parameterName, longName, Id);
}
}
}
protected virtual void CreateParametersInternal(Document doc, Element element)
{
if (element != null)
{
// Set the element name.
SetName(doc, element);
// Set the element description.
SetDescription(doc, element);
// The list of materials.
setMaterialParameter(doc, element);
// Set the element GUID.
bool elementIsType = (element is ElementType);
BuiltInParameter ifcGUIDId = elementIsType ? BuiltInParameter.IFC_TYPE_GUID : BuiltInParameter.IFC_GUID;
Parameter guidParam = element.get_Parameter(ifcGUIDId);
if (guidParam != null && !guidParam.IsReadOnly)
{
guidParam.Set(GlobalId);
}
else
{
ExporterIFCUtils.AddValueString(element, new ElementId(ifcGUIDId), GlobalId);
}
// Set the "IfcExportAs" parameter.
string ifcExportAs = IFCCategoryUtil.GetCustomCategoryName(this);
if (!string.IsNullOrWhiteSpace(ifcExportAs))
{
IFCPropertySet.AddParameterString(doc, element, "IfcExportAs", ifcExportAs, Id);
}
// Add property set-based parameters.
// We are going to create this "fake" parameter so that we can filter elements in schedules based on their property sets.
string propertySetListName = elementIsType ? "Type IfcPropertySetList" : "IfcPropertySetList";
IFCPropertySet.AddParameterString(doc, element, propertySetListName, "", Id);
}
}
/// <summary>
/// Add a parameter "IfcMaterial" to an element containing the name(s) of the materials of the generating entity.
/// </summary>
/// <param name="doc">The document.</param>
/// <param name="element">The created element.</param>
/// <remarks>Note that this field contains the names of the materials, and as such is not parametric in any way.</remarks>
private void SetMaterialParameter(Document doc, Element element)
{
string materialNames = null;
IList <string> materialsAndThickness = GetMaterialsNamesAndThicknesses();
foreach (string val in materialsAndThickness)
{
if (materialNames == null)
{
materialNames = val;
}
else
{
materialNames += ";" + val;
}
}
if (materialNames != null)
{
IFCPropertySet.AddParameterString(doc, element, this, IFCSharedParameters.IfcMaterial, materialNames, Id);
}
}
/// <summary>
/// Creates or populates Revit element params based on the information contained in this class.
/// </summary>
/// <param name="doc">The document.</param>
/// <param name="element">The element.</param>
protected override void CreateParametersInternal(Document doc, Element element)
{
base.CreateParametersInternal(doc, element);
if (element != null)
{
// Set "IfcPresentationLayer" parameter.
string ifcPresentationLayer = null;
foreach (string currLayer in PresentationLayerNames)
{
if (string.IsNullOrWhiteSpace(currLayer))
{
continue;
}
if (ifcPresentationLayer == null)
{
ifcPresentationLayer = currLayer;
}
else
{
ifcPresentationLayer += "; " + currLayer;
}
}
if (ifcPresentationLayer != null)
{
IFCPropertySet.AddParameterString(doc, element, "IfcPresentationLayer", ifcPresentationLayer, Id);
}
// Set the container name of the element.
string containerName = (ContainingStructure != null) ? ContainingStructure.Name : null;
if (containerName != null)
{
IFCPropertySet.AddParameterString(doc, element, "IfcSpatialContainer", containerName, Id);
}
}
}
/// <summary>
/// Creates or populates Revit element params based on the information contained in this class.
/// </summary>
/// <param name="doc">The document.</param>
/// <param name="element">The element.</param>
protected override void CreateParametersInternal(Document doc, Element element)
{
base.CreateParametersInternal(doc, element);
if (element != null)
{
Category category = IFCPropertySet.GetCategoryForParameterIfValid(element, Id);
// Set "Tag" parameter.
string ifcTag = Tag;
if (!string.IsNullOrWhiteSpace(ifcTag))
{
IFCPropertySet.AddParameterString(doc, element, category, this, "IfcTag", ifcTag, Id);
}
// Set "ProxyType" parameter.
string ifcProxyType = ProxyType;
if (!string.IsNullOrWhiteSpace(ifcProxyType))
{
IFCPropertySet.AddParameterString(doc, element, category, this, "IfcProxyType", ifcProxyType, Id);
}
}
}
/// <summary>
/// Add parameter "IfcSystem" to an element containing the name(s) of the system(s) of the generating entity.
/// </summary>
/// <param name="doc">The document.</param>
/// <param name="element">The created element.</param>
/// <param name="category">The element's category.</param>
/// <remarks>Note that this field contains the names of the systems, and as such is not parametric in any way.</remarks>
private void SetSystemParameter(Document doc, Element element, Category category)
{
if (category == null)
{
return;
}
string systemNames = null;
foreach (IFCGroup assignmentGroup in AssignmentGroups)
{
if (!(assignmentGroup is IFCSystem))
{
continue;
}
string name = assignmentGroup.Name;
if (string.IsNullOrWhiteSpace(name))
{
continue;
}
if (systemNames == null)
{
systemNames = name;
}
else
{
systemNames += ";" + name;
}
}
if (systemNames != null)
{
IFCPropertySet.AddParameterString(doc, element, category, this, "IfcSystem", systemNames, Id);
}
}
/// <summary>
/// Set the Element.Name property if possible, and add an "IfcName" parameter to an element containing the original name of the generating entity.
/// </summary>
/// <param name="doc">The document.</param>
/// <param name="element">The created element.</param>
private void SetName(Document doc, Element element)
{
string revitName = GetName(null);
if (!string.IsNullOrWhiteSpace(revitName))
{
try
{
if (CanSetRevitName(element))
{
element.Name = revitName;
}
}
catch
{
}
}
string name = string.IsNullOrWhiteSpace(Name) ? "" : Name;
// 2015: Revit links don't show the name of a selected item inside the link.
// 2015: DirectShapes don't have a built-in "Name" parameter.
IFCPropertySet.AddParameterString(doc, element, "IfcName", Name, Id);
}
private static void UpdateDocumentFileMetrics(Document doc, string ifcFileName)
{
FileInfo infoIFC = null;
try
{
infoIFC = new FileInfo(ifcFileName);
}
catch
{
return;
}
ProjectInfo projInfo = doc.ProjectInformation;
if (projInfo == null)
{
return;
}
long ifcFileLength = infoIFC.Length;
Int64 ticks = infoIFC.LastWriteTimeUtc.Ticks;
// If we find our parameters, but they are the wrong type, return.
Parameter originalFileName = projInfo.LookupParameter("Original IFC File Name");
if (originalFileName != null && originalFileName.StorageType != StorageType.String)
{
return;
}
Parameter originalFileSizeParam = projInfo.LookupParameter("Original IFC File Size");
if (originalFileSizeParam != null && originalFileSizeParam.StorageType != StorageType.String)
{
return;
}
Parameter originalTimeStampParam = projInfo.LookupParameter("Revit File Last Updated");
if (originalTimeStampParam != null && originalTimeStampParam.StorageType != StorageType.String)
{
return;
}
Parameter originalImporterVersion = projInfo.LookupParameter("Revit Importer Version");
if (originalTimeStampParam != null && originalTimeStampParam.StorageType != StorageType.String)
{
return;
}
if (originalFileName != null)
{
originalFileName.Set(ifcFileName);
}
else
{
IFCPropertySet.AddParameterString(doc, projInfo, "Original IFC File Name", ifcFileName, -1);
}
if (originalFileSizeParam != null)
{
originalFileSizeParam.Set(ifcFileLength.ToString());
}
else
{
IFCPropertySet.AddParameterString(doc, projInfo, "Original IFC File Size", ifcFileLength.ToString(), -1);
}
if (originalTimeStampParam != null)
{
originalTimeStampParam.Set(ticks.ToString());
}
else
{
IFCPropertySet.AddParameterString(doc, projInfo, "Revit File Last Updated", ticks.ToString(), -1);
}
if (originalImporterVersion != null)
{
originalImporterVersion.Set(IFCImportOptions.ImporterVersion);
}
else
{
IFCPropertySet.AddParameterString(doc, projInfo, "Revit Importer Version", IFCImportOptions.ImporterVersion, -1);
}
}
/// <summary>
/// Create a property for a given element.
/// </summary>
/// <param name="doc">The document.</param>
/// <param name="element">The element being created.</param>
/// <param name="category">The category of the element being created.</param>
/// <param name="parameterMap">The parameters of the element. Cached for performance.</param>
/// <param name="propertySetName">The name of the containing property set.</param>
/// <param name="createdParameters">The names of the created parameters.</param>
public void Create(Document doc, Element element, Category category, IFCObjectDefinition objDef, IFCParameterSetByGroup parameterGroupMap, string propertySetName, ISet <string> createdParameters)
{
// Try to get the single value from the property. If we can't get a single value, get it as a string.
IFCPropertyValue propertyValueToUse = null;
if (this is IFCSimpleProperty)
{
IFCSimpleProperty simpleProperty = this as IFCSimpleProperty;
IList <IFCPropertyValue> propertyValues = simpleProperty.IFCPropertyValues;
if (propertyValues != null && propertyValues.Count == 1)
{
// If the value isn't set, skip it. We won't warn.
if (!propertyValues[0].HasValue())
{
return;
}
propertyValueToUse = propertyValues[0];
}
}
IFCDataPrimitiveType dataType = IFCDataPrimitiveType.Unknown;
ForgeTypeId specTypeId = new ForgeTypeId();
ForgeTypeId unitsTypeId = null;
bool? boolValueToUse = null;
IFCLogical?logicalValueToUse = null;
int? intValueToUse = null;
double? doubleValueToUse = null;
ElementId elementIdValueToUse = null;
string stringValueToUse = null;
if (propertyValueToUse == null)
{
string propertyValueAsString = PropertyValueAsString();
if (propertyValueAsString == null)
{
Importer.TheLog.LogError(Id, "Couldn't create parameter: " + Name, false);
return;
}
dataType = IFCDataPrimitiveType.String;
stringValueToUse = propertyValueAsString;
}
else
{
dataType = propertyValueToUse.Value.PrimitiveType;
if (dataType == IFCDataPrimitiveType.Instance)
{
IFCAnyHandle propertyValueHandle = propertyValueToUse.Value.AsInstance();
ElementId propertyValueAsId = IFCObjectReferenceSelect.ToElementId(propertyValueHandle);
if (propertyValueAsId != ElementId.InvalidElementId)
{
elementIdValueToUse = propertyValueAsId;
}
else
{
stringValueToUse = IFCObjectReferenceSelect.ToString(propertyValueHandle);
dataType = IFCDataPrimitiveType.String;
}
}
else
{
switch (dataType)
{
case IFCDataPrimitiveType.String:
case IFCDataPrimitiveType.Enumeration:
case IFCDataPrimitiveType.Binary:
stringValueToUse = propertyValueToUse.AsString();
break;
case IFCDataPrimitiveType.Integer:
intValueToUse = propertyValueToUse.AsInteger();
break;
case IFCDataPrimitiveType.Boolean:
boolValueToUse = propertyValueToUse.AsBoolean();
break;
case IFCDataPrimitiveType.Logical:
logicalValueToUse = propertyValueToUse.AsLogical();
break;
case IFCDataPrimitiveType.Double:
if (propertyValueToUse.IFCUnit != null)
{
specTypeId = propertyValueToUse.IFCUnit.Spec;
unitsTypeId = propertyValueToUse.IFCUnit.Unit;
}
else
{
specTypeId = IFCDataUtil.GetUnitTypeFromData(propertyValueToUse.Value, SpecTypeId.Number);
}
doubleValueToUse = Importer.TheProcessor.ScaleValues ?
propertyValueToUse.AsScaledDouble() :
propertyValueToUse.AsUnscaledDouble();
break;
default:
Importer.TheLog.LogError(Id, "Unknown value type for parameter: " + Name, false);
return;
}
}
}
if (stringValueToUse != null && stringValueToUse.Length == 0)
{
return;
}
Parameter existingParameter = null;
bool elementIsType = (element is ElementType);
string typeString = elementIsType ? " " + Resources.IFCTypeSchedule : string.Empty;
string originalParameterName = propertySetName + "." + Name + typeString;
string parameterName = originalParameterName;
if (parameterGroupMap.TryFindParameter(parameterName, out existingParameter))
{
if ((existingParameter != null) && !IsValidParameterType(existingParameter, dataType))
{
existingParameter = null;
}
}
if (existingParameter == null)
{
int parameterNameCount = 2;
while (createdParameters.Contains(parameterName))
{
parameterName = originalParameterName + " " + parameterNameCount;
parameterNameCount++;
}
if (parameterNameCount > 2)
{
Importer.TheLog.LogWarning(Id, "Renamed parameter: " + originalParameterName + " to: " + parameterName, false);
}
bool created = false;
switch (dataType)
{
case IFCDataPrimitiveType.String:
case IFCDataPrimitiveType.Enumeration:
case IFCDataPrimitiveType.Binary:
created = IFCPropertySet.AddParameterString(doc, element, category, objDef, parameterName, stringValueToUse, Id);
break;
case IFCDataPrimitiveType.Integer:
created = IFCPropertySet.AddParameterInt(doc, element, category, objDef, parameterName, intValueToUse.Value, Id);
break;
case IFCDataPrimitiveType.Boolean:
created = IFCPropertySet.AddParameterBoolean(doc, element, category, objDef, parameterName, boolValueToUse.Value, Id);
break;
case IFCDataPrimitiveType.Logical:
if (logicalValueToUse != IFCLogical.Unknown)
{
created = IFCPropertySet.AddParameterBoolean(doc, element, category, objDef, parameterName, (logicalValueToUse == IFCLogical.True), Id);
}
break;
case IFCDataPrimitiveType.Double:
created = IFCPropertySet.AddParameterDouble(doc, element, category, objDef, parameterName, specTypeId, unitsTypeId, doubleValueToUse.Value, Id);
break;
case IFCDataPrimitiveType.Instance:
created = IFCPropertySet.AddParameterElementId(doc, element, category, objDef, parameterName, elementIdValueToUse, Id);
break;
}
if (created)
{
createdParameters.Add(originalParameterName);
}
return;
}
bool couldSetValue = false;
switch (existingParameter.StorageType)
{
case StorageType.String:
{
switch (dataType)
{
case IFCDataPrimitiveType.String:
case IFCDataPrimitiveType.Enumeration:
case IFCDataPrimitiveType.Binary:
couldSetValue = existingParameter.Set(stringValueToUse);
break;
case IFCDataPrimitiveType.Integer:
couldSetValue = existingParameter.Set(intValueToUse.Value.ToString());
break;
case IFCDataPrimitiveType.Boolean:
couldSetValue = existingParameter.Set(boolValueToUse.Value ? "True" : "False");
break;
case IFCDataPrimitiveType.Logical:
couldSetValue = existingParameter.Set(logicalValueToUse.ToString());
break;
case IFCDataPrimitiveType.Double:
couldSetValue = existingParameter.Set(doubleValueToUse.ToString());
break;
default:
break;
}
}
break;
case StorageType.Integer:
if (dataType == IFCDataPrimitiveType.Integer)
{
couldSetValue = existingParameter.Set(intValueToUse.Value);
}
else if (dataType == IFCDataPrimitiveType.Boolean)
{
couldSetValue = existingParameter.Set(boolValueToUse.Value ? 1 : 0);
}
else if (dataType == IFCDataPrimitiveType.Logical)
{
couldSetValue = (logicalValueToUse == IFCLogical.Unknown) ? true : existingParameter.Set((logicalValueToUse == IFCLogical.True) ? 1 : 0);
}
break;
case StorageType.Double:
if (dataType == IFCDataPrimitiveType.Double)
{
couldSetValue = existingParameter.Set(doubleValueToUse.Value);
}
else if (dataType == IFCDataPrimitiveType.Integer)
{
couldSetValue = existingParameter.Set(intValueToUse.Value);
}
else if (dataType == IFCDataPrimitiveType.Boolean)
{
couldSetValue = existingParameter.Set(boolValueToUse.Value ? 1 : 0);
}
else if ((dataType == IFCDataPrimitiveType.Logical) && (logicalValueToUse != IFCLogical.Unknown))
{
couldSetValue = existingParameter.Set((logicalValueToUse == IFCLogical.True) ? 1 : 0);
}
break;
}
if (!couldSetValue)
{
Importer.TheLog.LogError(Id, "Couldn't create parameter: " + Name + " of storage type: " + existingParameter.StorageType.ToString(), false);
}
}
/// <summary>
/// Processes IfcProject attributes.
/// </summary>
/// <param name="ifcProjectHandle">The IfcProject handle.</param>
protected override void Process(IFCAnyHandle ifcProjectHandle)
{
IFCAnyHandle unitsInContext = IFCImportHandleUtil.GetRequiredInstanceAttribute(ifcProjectHandle, "UnitsInContext", false);
if (!IFCAnyHandleUtil.IsNullOrHasNoValue(unitsInContext))
{
IList <IFCAnyHandle> units = IFCAnyHandleUtil.GetAggregateInstanceAttribute <List <IFCAnyHandle> >(unitsInContext, "Units");
if (units != null)
{
m_UnitsInContext = new HashSet <IFCUnit>();
foreach (IFCAnyHandle unit in units)
{
IFCUnit ifcUnit = IFCImportFile.TheFile.IFCUnits.ProcessIFCProjectUnit(unit);
if (!IFCUnit.IsNullOrInvalid(ifcUnit))
{
m_UnitsInContext.Add(ifcUnit);
}
}
}
else
{
Importer.TheLog.LogMissingRequiredAttributeError(unitsInContext, "Units", false);
}
}
var application = IFCImportFile.TheFile.Document.Application;
var projectUnits = IFCImportFile.TheFile.IFCUnits.GetIFCProjectUnit(SpecTypeId.Length);
IFCImportFile.TheFile.VertexTolerance = application.VertexTolerance;
IFCImportFile.TheFile.ShortCurveTolerance = application.ShortCurveTolerance;
Importer.TheProcessor.PostProcessProject(projectUnits?.ScaleFactor, projectUnits?.Unit);
// We need to process the units before we process the rest of the file, since we will scale values as we go along.
base.Process(ifcProjectHandle);
// process true north - take the first valid representation context that has a true north value.
HashSet <IFCAnyHandle> repContexts = IFCAnyHandleUtil.GetAggregateInstanceAttribute <HashSet <IFCAnyHandle> >(ifcProjectHandle, "RepresentationContexts");
bool hasMapConv = false;
XYZ geoRef = XYZ.Zero;
string geoRefName = null;
double trueNorth = 0.0;
if (repContexts != null)
{
foreach (IFCAnyHandle geomRepContextHandle in repContexts)
{
if (!IFCAnyHandleUtil.IsNullOrHasNoValue(geomRepContextHandle) &&
IFCAnyHandleUtil.IsSubTypeOf(geomRepContextHandle, IFCEntityType.IfcGeometricRepresentationContext))
{
IFCRepresentationContext context = IFCRepresentationContext.ProcessIFCRepresentationContext(geomRepContextHandle);
if (TrueNorthDirection == null && context.TrueNorth != null)
{
// TODO: Verify that we don't have inconsistent true norths. If we do, warn.
TrueNorthDirection = new UV(context.TrueNorth.X, context.TrueNorth.Y);
}
if (WorldCoordinateSystem == null && context.WorldCoordinateSystem != null && !context.WorldCoordinateSystem.IsIdentity)
{
WorldCoordinateSystem = context.WorldCoordinateSystem;
}
// Process Map Conversion if any
HashSet <IFCAnyHandle> coordOperation = IFCAnyHandleUtil.GetAggregateInstanceAttribute <HashSet <IFCAnyHandle> >(geomRepContextHandle, "HasCoordinateOperation");
if (coordOperation != null)
{
if (coordOperation.Count > 0)
{
if (IFCAnyHandleUtil.IsSubTypeOf(coordOperation.FirstOrDefault(), IFCEntityType.IfcMapConversion))
{
hasMapConv = true;
IFCAnyHandle mapConv = coordOperation.FirstOrDefault();
bool found = false;
double eastings = IFCImportHandleUtil.GetRequiredScaledLengthAttribute(mapConv, "Eastings", out found);
if (!found)
{
eastings = 0.0;
}
double northings = IFCImportHandleUtil.GetRequiredScaledLengthAttribute(mapConv, "Northings", out found);
if (!found)
{
northings = 0.0;
}
double orthogonalHeight = IFCImportHandleUtil.GetRequiredScaledLengthAttribute(mapConv, "OrthogonalHeight", out found);
if (!found)
{
orthogonalHeight = 0.0;
}
double xAxisAbs = IFCImportHandleUtil.GetOptionalRealAttribute(mapConv, "XAxisAbscissa", 1.0);
double xAxisOrd = IFCImportHandleUtil.GetOptionalRealAttribute(mapConv, "XAxisOrdinate", 0.0);
trueNorth = Math.Atan2(xAxisOrd, xAxisAbs);
//angleToNorth = -((xAxisAngle > -Math.PI / 2.0) ? xAxisAngle - Math.PI / 2.0 : xAxisAngle + Math.PI * 1.5);
double scale = IFCImportHandleUtil.GetOptionalRealAttribute(mapConv, "Scale", 1.0);
geoRef = new XYZ(scale * eastings, scale * northings, scale * orthogonalHeight);
// Process the IfcProjectedCRS
IFCAnyHandle projCRS = IFCAnyHandleUtil.GetInstanceAttribute(mapConv, "TargetCRS");
if (projCRS != null && IFCAnyHandleUtil.IsSubTypeOf(projCRS, IFCEntityType.IfcProjectedCRS))
{
geoRefName = IFCImportHandleUtil.GetRequiredStringAttribute(projCRS, "Name", false);
string desc = IFCImportHandleUtil.GetOptionalStringAttribute(projCRS, "Description", null);
string geodeticDatum = IFCImportHandleUtil.GetOptionalStringAttribute(projCRS, "GeodeticDatum", null);
string verticalDatum = IFCImportHandleUtil.GetOptionalStringAttribute(projCRS, "VerticalDatum", null);
string mapProj = IFCImportHandleUtil.GetOptionalStringAttribute(projCRS, "MapProjection", null);
string mapZone = IFCImportHandleUtil.GetOptionalStringAttribute(projCRS, "MapZone", null);
IFCAnyHandle mapUnit = IFCImportHandleUtil.GetOptionalInstanceAttribute(projCRS, "MapUnit");
Document doc = IFCImportFile.TheFile.Document;
ProjectInfo projectInfo = doc.ProjectInformation;
// We add this here because we want to make sure that external processors (e.g., Navisworks)
// get a chance to add a container for the parameters that get added below. In general,
// we should probably augment Processor.AddParameter to ensure that CreateOrUpdateElement
// is called before anything is attempted to be added. This is a special case, though,
// as in Revit we don't actually create an element for the IfcProject.
Importer.TheProcessor.CreateOrUpdateElement(Id, GlobalId, EntityType.ToString(), CategoryId.IntegerValue, null);
Category category = IFCPropertySet.GetCategoryForParameterIfValid(projectInfo, Id);
IFCPropertySet.AddParameterString(doc, projectInfo, category, this, "IfcProjectedCRS.Name", geoRefName, Id);
if (!string.IsNullOrEmpty(desc))
{
IFCPropertySet.AddParameterString(doc, projectInfo, category, this, "IfcProjectedCRS.Description", desc, Id);
}
if (!string.IsNullOrEmpty(geodeticDatum))
{
IFCPropertySet.AddParameterString(doc, projectInfo, category, this, "IfcProjectedCRS.GeodeticDatum", geodeticDatum, Id);
}
if (!string.IsNullOrEmpty(verticalDatum))
{
IFCPropertySet.AddParameterString(doc, projectInfo, category, this, "IfcProjectedCRS.VerticalDatum", verticalDatum, Id);
}
if (!string.IsNullOrEmpty(mapProj))
{
IFCPropertySet.AddParameterString(doc, projectInfo, category, this, "IfcProjectedCRS.MapProjection", mapProj, Id);
}
if (!string.IsNullOrEmpty(mapZone))
{
IFCPropertySet.AddParameterString(doc, projectInfo, category, this, "IfcProjectedCRS.MapZone", mapZone, Id);
}
if (!IFCAnyHandleUtil.IsNullOrHasNoValue(mapUnit))
{
IFCUnit mapUnitIfc = IFCUnit.ProcessIFCUnit(mapUnit);
string unitStr = UnitUtils.GetTypeCatalogStringForUnit(mapUnitIfc.Unit);
IFCPropertySet.AddParameterString(doc, projectInfo, category, this, "IfcProjectedCRS.MapUnit", unitStr, Id);
double convFactor = UnitUtils.Convert(1.0, mapUnitIfc.Unit, IFCImportFile.TheFile.IFCUnits.GetIFCProjectUnit(SpecTypeId.Length).Unit);
eastings = convFactor * eastings;
northings = convFactor * northings;
orthogonalHeight = convFactor * orthogonalHeight;
geoRef = new XYZ(eastings, northings, orthogonalHeight);
}
}
}
}
}
}
}
ProjectLocation projectLocation = IFCImportFile.TheFile.Document.ActiveProjectLocation;
ProjectPosition projectPosition;
if (projectLocation != null)
{
if (hasMapConv)
{
projectPosition = new ProjectPosition(geoRef.X, geoRef.Y, geoRef.Z, trueNorth);
projectLocation.SetProjectPosition(XYZ.Zero, projectPosition);
if (!string.IsNullOrEmpty(geoRefName))
{
IFCImportFile.TheFile.Document.SiteLocation.SetGeoCoordinateSystem(geoRefName);
}
}
else
{
// Set initial project location based on the information above.
// This may be further modified by the site.
trueNorth = 0.0;
if (TrueNorthDirection != null)
{
trueNorth = -Math.Atan2(-TrueNorthDirection.U, TrueNorthDirection.V);
}
// TODO: Extend this to work properly if the world coordinate system
// isn't a simple translation.
XYZ origin = XYZ.Zero;
if (WorldCoordinateSystem != null)
{
geoRef = WorldCoordinateSystem.Origin;
double angleRot = Math.Atan2(WorldCoordinateSystem.BasisX.Y, WorldCoordinateSystem.BasisX.X);
// If it is translation only, or if the WCS rotation is equal to trueNorth, we assume they are the same
if (WorldCoordinateSystem.IsTranslation ||
MathUtil.IsAlmostEqual(angleRot, trueNorth))
{
WorldCoordinateSystem = null;
}
else
{
// If the trueNorth is not set (=0), set the trueNorth by the rotation of the WCS, otherwise add the angle
if (MathUtil.IsAlmostZero(trueNorth))
{
trueNorth = angleRot;
}
else
{
trueNorth += angleRot;
}
WorldCoordinateSystem = null;
}
}
projectPosition = new ProjectPosition(geoRef.X, geoRef.Y, geoRef.Z, trueNorth);
projectLocation.SetProjectPosition(XYZ.Zero, projectPosition);
}
}
}
}
protected virtual void CreateParametersInternal(Document doc, Element element)
{
if (element != null)
{
Category category = IFCPropertySet.GetCategoryForParameterIfValid(element, Id);
// Set the element name.
SetName(doc, element, category);
// Set the element description.
SetDescription(doc, element, category);
// The list of materials.
SetMaterialParameter(doc, element, category);
// Set the "IfcSystem" parameter.
SetSystemParameter(doc, element, category);
// Set the element GUID.
bool elementIsType = (element is ElementType);
BuiltInParameter ifcGUIDId = GetGUIDParameter(element, elementIsType);
Parameter guidParam = element.get_Parameter(ifcGUIDId);
if (guidParam != null)
{
if (!guidParam.IsReadOnly)
{
guidParam.Set(GlobalId);
}
}
else
{
ExporterIFCUtils.AddValueString(element, new ElementId(ifcGUIDId), GlobalId);
}
// Set the "IfcExportAs" parameter.
string ifcExportAs = IFCCategoryUtil.GetCustomCategoryName(this);
if (!string.IsNullOrWhiteSpace(ifcExportAs))
{
IFCPropertySet.AddParameterString(doc, element, category, this, IFCSharedParameters.IfcExportAs, ifcExportAs, Id);
}
// Set the IFCElementAssembly Parameter
if (Decomposes != null)
{
string containerParamName = (Decomposes is IFCElementAssembly) ? "IfcElementAssembly" : "IfcDecomposes";
string containerParamGUIDName = (Decomposes is IFCElementAssembly) ? "IfcElementAssemblyGUID" : "IfcDecomposesGUID";
IFCPropertySet.AddParameterString(doc, element, category, containerParamName, Decomposes.Name, Id);
IFCPropertySet.AddParameterString(doc, element, category, containerParamGUIDName, Decomposes.GlobalId, Id);
}
// Set additional parameters (if any), e.g. for Classification assignments
if (AdditionalIntParameters.Count > 0)
{
foreach (KeyValuePair <string, object> parItem in AdditionalIntParameters)
{
if (parItem.Value is string)
{
IFCPropertySet.AddParameterString(doc, element, category, parItem.Key, (string)parItem.Value, Id);
}
else if (parItem.Value is double)
{
IFCPropertySet.AddParameterDouble(doc, element, category, parItem.Key, SpecTypeId.Custom, (double)parItem.Value, Id);
}
else if (parItem.Value is int)
{
IFCPropertySet.AddParameterInt(doc, element, category, parItem.Key, (int)parItem.Value, Id);
}
else if (parItem.Value is bool)
{
IFCPropertySet.AddParameterBoolean(doc, element, category, parItem.Key, (bool)parItem.Value, Id);
}
}
}
}
}
protected virtual void CreateParametersInternal(Document doc, Element element)
{
if (element != null)
{
// Set the element name.
SetName(doc, element);
// Set the element description.
SetDescription(doc, element);
// The list of materials.
SetMaterialParameter(doc, element);
// Set the "IfcSystem" parameter.
SetSystemParameter(doc, element);
// Set the element GUID.
bool elementIsType = (element is ElementType);
BuiltInParameter ifcGUIDId = GetGUIDParameter(element, elementIsType);
Parameter guidParam = element.get_Parameter(ifcGUIDId);
if (guidParam != null)
{
if (!guidParam.IsReadOnly)
{
guidParam.Set(GlobalId);
}
}
else
{
ExporterIFCUtils.AddValueString(element, new ElementId(ifcGUIDId), GlobalId);
}
// Set the "IfcExportAs" parameter.
string ifcExportAs = IFCCategoryUtil.GetCustomCategoryName(this);
if (!string.IsNullOrWhiteSpace(ifcExportAs))
{
IFCPropertySet.AddParameterString(doc, element, "IfcExportAs", ifcExportAs, Id);
}
// Add property set-based parameters.
// We are going to create this "fake" parameter so that we can filter elements in schedules based on their property sets.
string propertySetListName = elementIsType ? "Type IfcPropertySetList" : "IfcPropertySetList";
IFCPropertySet.AddParameterString(doc, element, propertySetListName, "", Id);
// Set the IFCElementAssembly Parameter
if (Decomposes != null && Decomposes is IFCElementAssembly)
{
IFCPropertySet.AddParameterString(doc, element, "IfcElementAssembly", Decomposes.Name, Id);
}
// Set additional parameters (if any), e.g. for Classification assignments
if (AdditionalIntParameters.Count > 0)
{
foreach (KeyValuePair <string, object> parItem in AdditionalIntParameters)
{
if (parItem.Value is string)
{
IFCPropertySet.AddParameterString(doc, element, parItem.Key, (string)parItem.Value, Id);
}
else if (parItem.Value is double)
{
IFCPropertySet.AddParameterDouble(doc, element, parItem.Key, UnitType.UT_Custom, (double)parItem.Value, Id);
}
else if (parItem.Value is int)
{
IFCPropertySet.AddParameterInt(doc, element, parItem.Key, (int)parItem.Value, Id);
}
else if (parItem.Value is bool)
{
IFCPropertySet.AddParameterBoolean(doc, element, parItem.Key, (bool)parItem.Value, Id);
}
}
}
}
}
protected virtual void CreateParametersInternal(Document doc, Element element)
{
if (element != null)
{
Category category = IFCPropertySet.GetCategoryForParameterIfValid(element, Id);
Importer.TheProcessor.CreateOrUpdateElement(Id, GlobalId, EntityType.ToString(), CategoryId.IntegerValue, null);
// Set the element name.
SetName(doc, element, category);
// Set the element description.
SetDescription(doc, element, category);
// The list of materials.
SetMaterialParameter(doc, element, category);
// Set the "IfcSystem" parameter.
SetSystemParameter(doc, element, category);
bool elementIsType = (element is ElementType);
if (!string.IsNullOrWhiteSpace(GlobalId))
{
BuiltInParameter ifcGUIDId = GetGUIDParameter(element, elementIsType);
Importer.TheProcessor.SetStringParameter(element, Id, ifcGUIDId, GlobalId, true);
}
// Set the built-in parameters.
(string entityName, string predefinedType) = IFCCategoryUtil.GetEntityNameAndPredefinedType(this);
if (!string.IsNullOrWhiteSpace(entityName))
{
BuiltInParameter ifcExportElementAsParam = elementIsType ? BuiltInParameter.IFC_EXPORT_ELEMENT_TYPE_AS : BuiltInParameter.IFC_EXPORT_ELEMENT_AS;
Importer.TheProcessor.SetStringParameter(element, Id, ifcExportElementAsParam, entityName, true);
}
if (!string.IsNullOrWhiteSpace(predefinedType))
{
BuiltInParameter ifcPredefinedTypeParam = elementIsType ? BuiltInParameter.IFC_EXPORT_PREDEFINEDTYPE_TYPE : BuiltInParameter.IFC_EXPORT_PREDEFINEDTYPE;
Importer.TheProcessor.SetStringParameter(element, Id, ifcPredefinedTypeParam, predefinedType, true);
}
// Set the IFCElementAssembly Parameter
if (Decomposes != null)
{
string containerParamName = (Decomposes is IFCElementAssembly) ? "IfcElementAssembly" : "IfcDecomposes";
string containerParamGUIDName = (Decomposes is IFCElementAssembly) ? "IfcElementAssemblyGUID" : "IfcDecomposesGUID";
IFCPropertySet.AddParameterString(doc, element, category, this, containerParamName, Decomposes.Name, Id);
IFCPropertySet.AddParameterString(doc, element, category, this, containerParamGUIDName, Decomposes.GlobalId, Id);
}
// Set additional parameters (if any), e.g. for Classification assignments
if (AdditionalIntParameters.Count > 0)
{
foreach (KeyValuePair <string, object> parItem in AdditionalIntParameters)
{
if (parItem.Value is string)
{
IFCPropertySet.AddParameterString(doc, element, category, this, parItem.Key, (string)parItem.Value, Id);
}
else if (parItem.Value is double)
{
IFCPropertySet.AddParameterDouble(doc, element, category, this, parItem.Key, SpecTypeId.Custom, UnitTypeId.General, (double)parItem.Value, Id);
}
else if (parItem.Value is int)
{
IFCPropertySet.AddParameterInt(doc, element, category, this, parItem.Key, (int)parItem.Value, Id);
}
else if (parItem.Value is bool)
{
IFCPropertySet.AddParameterBoolean(doc, element, category, this, parItem.Key, (bool)parItem.Value, Id);
}
}
}
}
}