/// <summary>
/// Processes an IFC unit in the property.
/// </summary>
/// <param name="ifcSimpleProperty">The simple property.</param>
/// <param name="simplePropertyHandle">The simple property handle.</param>
static protected void ProcessIFCSimplePropertyUnit(IFCSimpleProperty ifcSimpleProperty, IFCAnyHandle simplePropertyHandle)
{
IFCAnyHandle ifcUnitHandle = IFCImportHandleUtil.GetOptionalInstanceAttribute(simplePropertyHandle, "Unit");
IFCUnit ifcUnit = (ifcUnitHandle != null) ? IFCUnit.ProcessIFCUnit(ifcUnitHandle) : null;
if (ifcUnit == null)
{
if (ifcSimpleProperty.IFCPropertyValues.Count > 0)
{
IFCPropertyValue propertyValue = ifcSimpleProperty.IFCPropertyValues[0];
if (propertyValue != null && propertyValue.HasValue() &&
(propertyValue.Type == IFCDataPrimitiveType.Integer) || (propertyValue.Type == IFCDataPrimitiveType.Double))
{
string unitTypeName;
UnitType unitType = IFCDataUtil.GetUnitTypeFromData(propertyValue.Value, UnitType.UT_Undefined, out unitTypeName);
if (unitType != UnitType.UT_Undefined)
{
ifcUnit = IFCImportFile.TheFile.IFCUnits.GetIFCProjectUnit(unitType);
}
else
{
Importer.TheLog.LogWarning(simplePropertyHandle.StepId, "Unhandled unit type: " + unitTypeName, true);
}
}
}
}
ifcSimpleProperty.m_IFCUnit = ifcUnit;
}
/// <summary>
/// Processes an IFC physical simple quantity.
/// </summary>
/// <param name="ifcPhysicalQuantity">The IfcPhysicalSimpleQuantity object.</param>
/// <returns>The IFCPhysicalSimpleQuantity object.</returns>
override protected void Process(IFCAnyHandle ifcPhysicalSimpleQuantity)
{
base.Process(ifcPhysicalSimpleQuantity);
IFCAnyHandle unit = IFCImportHandleUtil.GetOptionalInstanceAttribute(ifcPhysicalSimpleQuantity, "Unit");
if (!IFCAnyHandleUtil.IsNullOrHasNoValue(unit))
{
IFCUnit = IFCUnit.ProcessIFCUnit(unit);
}
// Process subtypes of IfcPhysicalSimpleQuantity here.
string attributeName = ifcPhysicalSimpleQuantity.TypeName.Substring(11) + "Value";
Value = ifcPhysicalSimpleQuantity.GetAttribute(attributeName);
BaseUnitType = IFCDataUtil.GetUnitTypeFromData(Value, UnitType.UT_Undefined);
if (BaseUnitType == UnitType.UT_Undefined)
{
// Determine it from the attributeName.
if (string.Compare(attributeName, "LengthValue", true) == 0)
{
BaseUnitType = UnitType.UT_Length;
}
else if (string.Compare(attributeName, "AreaValue", true) == 0)
{
BaseUnitType = UnitType.UT_Area;
}
else if (string.Compare(attributeName, "VolumeValue", true) == 0)
{
BaseUnitType = UnitType.UT_Volume;
}
else if (string.Compare(attributeName, "CountValue", true) == 0)
{
BaseUnitType = UnitType.UT_Number;
}
else if (string.Compare(attributeName, "WeightValue", true) == 0)
{
BaseUnitType = UnitType.UT_Mass;
}
else if (string.Compare(attributeName, "TimeValue", true) == 0)
{
BaseUnitType = UnitType.UT_Number; // No time unit type in Revit.
}
else
{
Importer.TheLog.LogWarning(Id, "Can't determine unit type for IfcPhysicalSimpleQuantity of type: " + attributeName, true);
BaseUnitType = UnitType.UT_Number;
}
}
if (IFCUnit == null)
{
IFCUnit = IFCImportFile.TheFile.IFCUnits.GetIFCProjectUnit(BaseUnitType);
}
}
/// <summary>
/// Create a quantity for a given element.
/// </summary>
/// <param name="doc">The document.</param>
/// <param name="element">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 override void Create(Document doc, Element element, IFCParameterSetByGroup parameterGroupMap, string propertySetName, ISet <string> createdParameters)
{
double doubleValueToUse = IFCUnit != null?IFCUnit.Convert(Value.AsDouble()) : Value.AsDouble();
Parameter existingParameter = null;
string originalParameterName = Name + "(" + propertySetName + ")";
string parameterName = originalParameterName;
if (!parameterGroupMap.TryFindParameter(parameterName, out existingParameter))
{
int parameterNameCount = 2;
while (createdParameters.Contains(parameterName))
{
parameterName = originalParameterName + " " + parameterNameCount;
parameterNameCount++;
}
if (parameterNameCount > 2)
{
Importer.TheLog.LogWarning(Id, "Renamed parameter: " + originalParameterName + " to: " + parameterName, false);
}
if (existingParameter == null)
{
UnitType unitType = UnitType.UT_Undefined;
if (IFCUnit != null)
{
unitType = IFCUnit.UnitType;
}
else
{
unitType = IFCDataUtil.GetUnitTypeFromData(Value, UnitType.UT_Number);
}
bool created = IFCPropertySet.AddParameterDouble(doc, element, parameterName, unitType, doubleValueToUse, Id);
if (created)
{
createdParameters.Add(parameterName);
}
return;
}
}
bool setValue = true;
switch (existingParameter.StorageType)
{
case StorageType.String:
existingParameter.Set(doubleValueToUse.ToString());
break;
case StorageType.Double:
existingParameter.Set(doubleValueToUse);
break;
default:
setValue = false;
break;
}
if (!setValue)
{
Importer.TheLog.LogError(Id, "Couldn't create parameter: " + Name + " of storage type: " + existingParameter.StorageType.ToString(), false);
}
}
/// <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>
/// Create a quantity for a given element.
/// </summary>
/// <param name="doc">The document.</param>
/// <param name="element">The element being created.</param>
/// <param name="category">The element's category.</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 override void Create(Document doc, Element element, Category category, IFCObjectDefinition objDef, IFCParameterSetByGroup parameterGroupMap, string propertySetName, ISet <string> createdParameters)
{
double baseValue = 0.0;
IFCDataPrimitiveType type = Value.PrimitiveType;
switch (type)
{
case IFCDataPrimitiveType.Double:
baseValue = Value.AsDouble();
break;
case IFCDataPrimitiveType.Integer:
// This case isn't valid, but could happen when repairing a file
Importer.TheLog.LogWarning(Id, "Unexpected integer parameter type, repairing.", false);
baseValue = Value.AsInteger();
break;
default:
Importer.TheLog.LogError(Id, "Invalid parameter type: " + type.ToString() + " for IfcPhysicalSimpleQuantity", false);
return;
}
double doubleValueToUse = Importer.TheProcessor.ScaleValues ?
IFCUnit?.Convert(baseValue) ?? baseValue :
baseValue;
Parameter existingParameter = null;
string originalParameterName = propertySetName + "." + Name;
string parameterName = originalParameterName;
if (!parameterGroupMap.TryFindParameter(parameterName, out existingParameter))
{
int parameterNameCount = 2;
while (createdParameters.Contains(parameterName))
{
parameterName = originalParameterName + " " + parameterNameCount;
parameterNameCount++;
}
if (parameterNameCount > 2)
{
Importer.TheLog.LogWarning(Id, "Renamed parameter: " + originalParameterName + " to: " + parameterName, false);
}
if (existingParameter == null)
{
ForgeTypeId specTypeId;
ForgeTypeId unitsTypeId = null;
if (IFCUnit != null)
{
specTypeId = IFCUnit.Spec;
unitsTypeId = IFCUnit.Unit;
}
else
{
specTypeId = IFCDataUtil.GetUnitTypeFromData(Value, SpecTypeId.Number);
}
bool created = IFCPropertySet.AddParameterDouble(doc, element, category, objDef, parameterName, specTypeId, unitsTypeId, doubleValueToUse, Id);
if (created)
{
createdParameters.Add(parameterName);
}
return;
}
}
bool setValue = true;
switch (existingParameter.StorageType)
{
case StorageType.String:
existingParameter.Set(doubleValueToUse.ToString());
break;
case StorageType.Double:
existingParameter.Set(doubleValueToUse);
break;
default:
setValue = false;
break;
}
if (!setValue)
{
Importer.TheLog.LogError(Id, "Couldn't create parameter: " + Name + " of storage type: " + existingParameter.StorageType.ToString(), false);
}
}
