/// <summary>
/// Processes an IfcDoorPanelProperties entity.
/// </summary>
/// <param name="ifcDoorPanelProperties">The IfcDoorPanelProperties handle.</param>
protected override void Process(IFCAnyHandle ifcDoorPanelProperties)
{
base.Process(ifcDoorPanelProperties);
double currPropertyValue = IFCImportHandleUtil.GetOptionalScaledLengthAttribute(ifcDoorPanelProperties, "PanelDepth", -1e+30);
if (!MathUtil.IsAlmostEqual(currPropertyValue, -1e+30))
{
DoubleProperties[new Tuple <string, UnitType, AllowedValues>(GeneratePropertyName("PanelDepth"),
UnitType.UT_Length, AllowedValues.Positive)] = currPropertyValue;
}
currPropertyValue = IFCImportHandleUtil.GetOptionalRealAttribute(ifcDoorPanelProperties, "PanelWidth", -1e+30);
if (!MathUtil.IsAlmostEqual(currPropertyValue, -1e+30))
{
DoubleProperties[new Tuple <string, UnitType, AllowedValues>(GeneratePropertyName("PanelWidth"),
UnitType.UT_Length, AllowedValues.NonNegative)] = currPropertyValue;
}
string currPropertyValueString = IFCImportHandleUtil.GetOptionalStringAttribute(ifcDoorPanelProperties, "PanelOperation", null);
if (!string.IsNullOrEmpty(currPropertyValueString))
{
StringProperties[GeneratePropertyName("PanelOperation")] = currPropertyValueString;
}
currPropertyValueString = IFCImportHandleUtil.GetOptionalStringAttribute(ifcDoorPanelProperties, "PanelPosition", null);
if (!string.IsNullOrEmpty(currPropertyValueString))
{
StringProperties[GeneratePropertyName("PanelPosition")] = currPropertyValueString;
}
}
protected override void Process(IFCAnyHandle ifcMaterialProfile)
{
base.Process(ifcMaterialProfile);
IFCAnyHandle ifcMaterial = IFCImportHandleUtil.GetOptionalInstanceAttribute(ifcMaterialProfile, "Material");
if (!IFCAnyHandleUtil.IsNullOrHasNoValue(ifcMaterial))
{
Material = IFCMaterial.ProcessIFCMaterial(ifcMaterial);
}
IFCAnyHandle profileHnd = IFCImportHandleUtil.GetRequiredInstanceAttribute(ifcMaterialProfile, "Profile", true);
if (profileHnd != null)
{
Profile = IFCProfileDef.ProcessIFCProfileDef(profileHnd);
}
Name = IFCImportHandleUtil.GetOptionalStringAttribute(ifcMaterialProfile, "Name", null);
Description = IFCImportHandleUtil.GetOptionalStringAttribute(ifcMaterialProfile, "Description", null);
double prio = IFCImportHandleUtil.GetOptionalRealAttribute(ifcMaterialProfile, "Priority", -1);
if (prio >= 0)
{
Priority = prio;
}
Category = IFCImportHandleUtil.GetOptionalStringAttribute(ifcMaterialProfile, "Category", null);
return;
}
protected override void Process(IFCAnyHandle ifcMaterialConstituent)
{
base.Process(ifcMaterialConstituent);
IFCAnyHandle ifcMaterial = IFCImportHandleUtil.GetRequiredInstanceAttribute(ifcMaterialConstituent, "Material", true);
if (!IFCAnyHandleUtil.IsNullOrHasNoValue(ifcMaterial))
{
Material = IFCMaterial.ProcessIFCMaterial(ifcMaterial);
}
Name = IFCImportHandleUtil.GetOptionalStringAttribute(ifcMaterialConstituent, "Name", null);
Description = IFCImportHandleUtil.GetOptionalStringAttribute(ifcMaterialConstituent, "Description", null);
double fraction = IFCImportHandleUtil.GetOptionalRealAttribute(ifcMaterialConstituent, "Fraction", -1);
if (fraction >= 0)
{
Fraction = fraction;
}
Category = IFCImportHandleUtil.GetOptionalStringAttribute(ifcMaterialConstituent, "Category", null);
return;
}
override protected void Process(IFCAnyHandle item)
{
base.Process(item);
IFCAnyHandle localOrigin = IFCImportHandleUtil.GetRequiredInstanceAttribute(item, "LocalOrigin", false);
XYZ origin = null;
if (localOrigin != null)
{
origin = IFCPoint.ProcessScaledLengthIFCCartesianPoint(localOrigin);
}
else
{
origin = XYZ.Zero;
}
IFCAnyHandle axis1 = IFCImportHandleUtil.GetOptionalInstanceAttribute(item, "Axis1");
XYZ xAxis = null;
if (axis1 != null)
{
xAxis = IFCPoint.ProcessNormalizedIFCDirection(axis1);
}
IFCAnyHandle axis2 = IFCImportHandleUtil.GetOptionalInstanceAttribute(item, "Axis2");
XYZ yAxis = null;
if (axis2 != null)
{
yAxis = IFCPoint.ProcessNormalizedIFCDirection(axis2);
}
Scale = IFCImportHandleUtil.GetOptionalRealAttribute(item, "Scale", 1.0);
XYZ zAxis = null;
// Assume that the dimensionality of the IfcCartesianTransformationOperator is 2, unless determined otherwise below.
int dim = 2;
if (IFCAnyHandleUtil.IsSubTypeOf(item, IFCEntityType.IfcCartesianTransformationOperator2DnonUniform))
{
ScaleY = IFCImportHandleUtil.GetOptionalRealAttribute(item, "Scale2", Scale);
}
else if (IFCAnyHandleUtil.IsSubTypeOf(item, IFCEntityType.IfcCartesianTransformationOperator3D))
{
dim = 3;
IFCAnyHandle axis3 = IFCImportHandleUtil.GetOptionalInstanceAttribute(item, "Axis3");
if (axis3 != null)
{
zAxis = IFCPoint.ProcessNormalizedIFCDirection(axis3);
}
if (IFCAnyHandleUtil.IsSubTypeOf(item, IFCEntityType.IfcCartesianTransformationOperator3DnonUniform))
{
ScaleY = IFCImportHandleUtil.GetOptionalRealAttribute(item, "Scale2", Scale);
ScaleZ = IFCImportHandleUtil.GetOptionalRealAttribute(item, "Scale3", Scale);
}
}
// Set the axes based on what is specified.
Transform = CreateTransformUsingIfcBaseAxisCalculation(xAxis, yAxis, zAxis, origin, dim, Id);
}
/// <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);
}
}
}
}
override protected void Process(IFCAnyHandle item)
{
base.Process(item);
IFCAnyHandle localOrigin = IFCImportHandleUtil.GetRequiredInstanceAttribute(item, "LocalOrigin", false);
XYZ origin = null;
if (localOrigin != null)
{
origin = IFCPoint.ProcessScaledLengthIFCCartesianPoint(localOrigin);
}
else
{
origin = XYZ.Zero;
}
IFCAnyHandle axis1 = IFCImportHandleUtil.GetOptionalInstanceAttribute(item, "Axis1");
XYZ xAxis = null;
if (axis1 != null)
{
xAxis = IFCPoint.ProcessNormalizedIFCDirection(axis1);
}
IFCAnyHandle axis2 = IFCImportHandleUtil.GetOptionalInstanceAttribute(item, "Axis2");
XYZ yAxis = null;
if (axis2 != null)
{
yAxis = IFCPoint.ProcessNormalizedIFCDirection(axis2);
}
Scale = IFCImportHandleUtil.GetOptionalRealAttribute(item, "Scale", 1.0);
XYZ zAxis = null;
if (IFCAnyHandleUtil.IsSubTypeOf(item, IFCEntityType.IfcCartesianTransformationOperator2DnonUniform))
{
ScaleY = IFCImportHandleUtil.GetOptionalRealAttribute(item, "Scale2", Scale);
}
else if (IFCAnyHandleUtil.IsSubTypeOf(item, IFCEntityType.IfcCartesianTransformationOperator3D))
{
IFCAnyHandle axis3 = IFCImportHandleUtil.GetOptionalInstanceAttribute(item, "Axis3");
if (axis3 != null)
{
zAxis = IFCPoint.ProcessNormalizedIFCDirection(axis3);
}
if (IFCAnyHandleUtil.IsSubTypeOf(item, IFCEntityType.IfcCartesianTransformationOperator3DnonUniform))
{
ScaleY = IFCImportHandleUtil.GetOptionalRealAttribute(item, "Scale2", Scale);
ScaleZ = IFCImportHandleUtil.GetOptionalRealAttribute(item, "Scale3", Scale);
}
}
// Set the axes based on what is specified.
// If all three axes are set, ensure they are truly orthogonal.
// If two axes are set, ensure they are orthogonal and set the 3rd axis to be the cross product.
// If one axis is set, arbitrarily set the next axis to be the basis vector which
// If no axes are set, use identity transform.
if (xAxis == null)
{
if (yAxis == null)
{
if (zAxis == null)
{
xAxis = XYZ.BasisX;
yAxis = XYZ.BasisY;
zAxis = XYZ.BasisZ;
}
}
else if (zAxis == null)
{
// Special case - Y axis is in XY plane.
if (MathUtil.IsAlmostZero(yAxis[2]))
{
xAxis = new XYZ(yAxis[1], -yAxis[0], 0.0);
zAxis = XYZ.BasisZ;
}
else
{
throw new InvalidOperationException("#" + item.StepId + ": IfcCartesianTransformOperator has only y axis defined, ignoring.");
}
}
else
{
xAxis = yAxis.CrossProduct(zAxis);
}
}
else if (yAxis == null)
{
if (zAxis == null)
{
// Special case - X axis is in XY plane.
if (MathUtil.IsAlmostZero(xAxis[2]))
{
yAxis = new XYZ(xAxis[1], -xAxis[0], 0.0);
zAxis = XYZ.BasisZ;
}
else
{
throw new InvalidOperationException("#" + item.StepId + ": IfcCartesianTransformOperator has only x axis defined, ignoring.");
}
}
else
{
yAxis = zAxis.CrossProduct(xAxis);
}
}
else if (zAxis == null)
{
zAxis = xAxis.CrossProduct(yAxis);
}
// Make sure that the axes are really orthogonal.
if (!MathUtil.IsAlmostZero(xAxis.DotProduct(zAxis)))
{
zAxis = xAxis.CrossProduct(yAxis);
}
if (!MathUtil.IsAlmostZero(xAxis.DotProduct(yAxis)))
{
yAxis = zAxis.CrossProduct(xAxis);
}
Transform = Transform.CreateTranslation(origin);
Transform.set_Basis(0, xAxis);
Transform.set_Basis(1, yAxis);
Transform.set_Basis(2, zAxis);
}
