public static RectangularGeometry TogbXML_RectangularGeometry(this IClosedPlanar3D closedPlanar3D, double tolerance = Core.Tolerance.MicroDistance)
{
if (closedPlanar3D == null)
{
return(null);
}
Plane plane = closedPlanar3D.GetPlane();
Planar.BoundingBox2D boundingBox2D = plane.Convert(closedPlanar3D).GetBoundingBox();
double area_closedPlanar3D = closedPlanar3D.GetArea();
double area_boundingBox2D = boundingBox2D.GetArea();
double width = boundingBox2D.Width;
double height = boundingBox2D.Height;
if (System.Math.Abs(area_closedPlanar3D - area_boundingBox2D) > Core.Tolerance.MacroDistance)
{
//TODO: find better way to keep side ratio
width = System.Math.Sqrt(area_closedPlanar3D);
height = area_closedPlanar3D / width;
}
RectangularGeometry rectangularGeometry = new RectangularGeometry();
rectangularGeometry.Azimuth = Spatial.Query.Azimuth(closedPlanar3D, Vector3D.WorldY).ToString();
rectangularGeometry.Width = width.ToString();
rectangularGeometry.Height = height.ToString();
rectangularGeometry.CartesianPoint = plane.Convert(boundingBox2D.Min).TogbXML(tolerance);
rectangularGeometry.Tilt = Spatial.Query.Tilt(closedPlanar3D).ToString();
return(rectangularGeometry);
}
public static Face3D ToSAM(this HoneybeeSchema.Face3D face3D)
{
if (face3D == null)
{
return(null);
}
Plane plane = face3D.Plane?.ToSAM();
IClosedPlanar3D externalEdge3D = null;
List <Point3D> point3Ds = face3D.Boundary?.ToSAM();
if (point3Ds == null || point3Ds.Count < 3)
{
return(null);
}
if (plane != null)
{
externalEdge3D = new Polygon3D(plane, point3Ds.ConvertAll(x => plane.Convert(x)));
}
else
{
externalEdge3D = new Polygon3D(point3Ds);
}
plane = externalEdge3D.GetPlane();
if (plane == null)
{
return(null);
}
List <IClosedPlanar3D> internalEdge3Ds = null;
if (face3D.Holes != null)
{
internalEdge3Ds = new List <IClosedPlanar3D>();
foreach (List <List <double> > values in face3D.Holes)
{
point3Ds = values?.ToSAM();
if (point3Ds == null || point3Ds.Count < 3)
{
continue;
}
internalEdge3Ds.Add(new Polygon3D(plane, point3Ds.ConvertAll(x => plane.Convert(x))));
}
}
return(Face3D.Create(externalEdge3D.GetPlane(), plane.Convert(externalEdge3D), internalEdge3Ds?.ConvertAll(x => plane.Convert(x))));
}
public static PolyLoop TogbXML_PolyLoop(this IClosedPlanar3D closedPlanar3D, double tolerance = Core.Tolerance.MicroDistance)
{
if (closedPlanar3D == null)
{
return(null);
}
List <Point3D> point3Ds = null;
IClosedPlanar3D closedPlanar3D_Temp = null;
if (closedPlanar3D is Face3D)
{
closedPlanar3D_Temp = ((Face3D)closedPlanar3D).GetExternalEdge3D();
}
if (closedPlanar3D_Temp == null)
{
closedPlanar3D_Temp = closedPlanar3D;
}
if (closedPlanar3D_Temp is ISegmentable3D)
{
point3Ds = ((ISegmentable3D)closedPlanar3D_Temp).GetPoints();
}
if (point3Ds == null)
{
throw new System.NotImplementedException();
}
if (!Spatial.Query.Clockwise(closedPlanar3D_Temp, null, tolerance))
{
point3Ds.Reverse();
}
//Plane plane = Spatial.Create.Plane(point3Ds, tolerance);
//if (!plane.Normal.SameHalf(closedPlanar3D.GetPlane().Normal))
// point3Ds.Reverse();
PolyLoop polyLoop = new PolyLoop();
polyLoop.Points = point3Ds.ConvertAll(x => x.TogbXML(tolerance)).ToArray();
return(polyLoop);
}
public static global::Topologic.Face ToTopologic(this Face3D face3D)
{
IClosedPlanar3D closedPlanar3D = face3D.GetExternalEdge3D();
if (closedPlanar3D is ICurvable3D)
{
List <Edge> edges = new List <Edge>();
foreach (ICurve3D curve3D in ((ICurvable3D)closedPlanar3D).GetCurves())
{
Edge edge = Edge.ByStartVertexEndVertex(ToTopologic(curve3D.GetStart()), ToTopologic(curve3D.GetEnd()));
edges.Add(edge);
}
return(global::Topologic.Face.ByEdges(edges));
}
return(null);
}
public static List <Segment3D> Segment3Ds(this IClosedPlanar3D closedPlanar3D, double tolerance = Core.Tolerance.MacroDistance)
{
if (closedPlanar3D == null)
{
return(null);
}
if (!(closedPlanar3D is ICurvable3D))
{
return(null);
}
List <ICurve3D> curve3Ds = Spatial.Query.Explode(((ICurvable3D)closedPlanar3D).GetCurves());
if (curve3Ds == null)
{
return(null);
}
Plane plane = closedPlanar3D.GetPlane();
if (plane == null)
{
return(null);
}
List <Planar.Point2D> point2Ds = new List <Planar.Point2D>();
foreach (ICurve3D curve3D in curve3Ds)
{
if (curve3D == null)
{
continue;
}
Planar.Modify.Add(point2Ds, plane.Convert(curve3D.GetStart()), tolerance);
Planar.Modify.Add(point2Ds, plane.Convert(curve3D.GetEnd()), tolerance);
}
point2Ds = Planar.Query.SimplifyByAngle(point2Ds, true, tolerance);
return(Planar.Create.Segment2Ds(point2Ds, true)?.ConvertAll(x => plane.Convert(x)));
}
public static List <Segment3D> Segment3Ds(this IClosedPlanar3D closedPlanar3D, double tolerance_Distance = Core.Tolerance.Distance, double tolerance_Angle = Core.Tolerance.Angle)
{
if (closedPlanar3D == null)
{
return(null);
}
if (!(closedPlanar3D is ICurvable3D))
{
return(null);
}
List <ICurve3D> curve3Ds = Spatial.Query.Explode(((ICurvable3D)closedPlanar3D).GetCurves());
if (curve3Ds == null)
{
return(null);
}
List <Segment3D> segment3Ds = curve3Ds.ConvertAll(x => x as Segment3D);
if (segment3Ds.Contains(null))
{
return(null);
}
Spatial.Plane plane = closedPlanar3D.GetPlane();
if (plane == null)
{
return(null);
}
List <Planar.Segment2D> segment2Ds = segment3Ds.ConvertAll(x => plane.Convert(x));
segment2Ds.RemoveAll(x => x.GetLength() <= tolerance_Distance);
Planar.Query.SimplifyBySAM_Angle(segment2Ds, tolerance_Distance, tolerance_Angle);
segment2Ds = Planar.Query.Snap(segment2Ds);
return(segment2Ds.ConvertAll(x => plane.Convert(x)));
}
public static List <Shell> Shells(this Document document, IEnumerable <Autodesk.Revit.DB.Mechanical.Space> spaces = null, double offset = 0.1, double snapTolerance = Core.Tolerance.MacroDistance, double tolerance = Core.Tolerance.Distance)
{
if (document == null)
{
return(null);
}
//Collecting Space list
List <Autodesk.Revit.DB.Mechanical.Space> spaces_Temp = new FilteredElementCollector(document).OfCategory(BuiltInCategory.OST_MEPSpaces).Cast <Autodesk.Revit.DB.Mechanical.Space>().ToList();
if (spaces != null)
{
List <Autodesk.Revit.DB.Mechanical.Space> spaces_New = new List <Autodesk.Revit.DB.Mechanical.Space>();
foreach (Autodesk.Revit.DB.Mechanical.Space space in spaces)
{
int index = spaces_Temp.FindIndex(x => x.Id.IntegerValue == space.Id.IntegerValue);
if (index != -1)
{
spaces_New.Add(spaces_Temp[index]);
}
}
spaces_Temp = spaces_New;
}
if (spaces_Temp == null || spaces_Temp.Count == 0)
{
return(null);
}
//Dictionary of bottom elevations and tuples (top elevation, location 2D, Space) (Metric Units)
Dictionary <double, List <Tuple <double, Geometry.Planar.Point2D, Autodesk.Revit.DB.Mechanical.Space> > > dictionary = new Dictionary <double, List <Tuple <double, Geometry.Planar.Point2D, Autodesk.Revit.DB.Mechanical.Space> > >();
//Space cut elevations (Imperial Units)
HashSet <double> cutElevations = new HashSet <double>();
//Collecting Spaces data
foreach (Autodesk.Revit.DB.Mechanical.Space space in spaces_Temp)
{
XYZ xyz = (space.Location as LocationPoint)?.Point;
if (xyz == null)
{
continue;
}
double elevation_Top = double.NaN;
Parameter parameter = space.get_Parameter(BuiltInParameter.ROOM_UPPER_LEVEL);
if (parameter != null && parameter.HasValue)
{
ElementId elementId = parameter.AsElementId();
if (elementId != null && elementId != ElementId.InvalidElementId)
{
Level level = document.GetElement(elementId) as Level;
if (level != null)
{
#if Revit2017 || Revit2018 || Revit2019 || Revit2020
elevation_Top = UnitUtils.ConvertFromInternalUnits(level.Elevation, DisplayUnitType.DUT_METERS);
#else
elevation_Top = UnitUtils.ConvertFromInternalUnits(level.Elevation, UnitTypeId.Meters);
#endif
}
}
}
BoundingBoxXYZ boundingBoxXYZ = space.get_BoundingBox(null);
if (double.IsNaN(elevation_Top) && boundingBoxXYZ != null)
{
#if Revit2017 || Revit2018 || Revit2019 || Revit2020
elevation_Top = UnitUtils.ConvertFromInternalUnits(boundingBoxXYZ.Max.Z, DisplayUnitType.DUT_METERS);
#else
elevation_Top = UnitUtils.ConvertFromInternalUnits(boundingBoxXYZ.Max.Z, UnitTypeId.Meters);
#endif
}
double elevation_Bottom = double.NaN;
if (boundingBoxXYZ != null)
{
#if Revit2017 || Revit2018 || Revit2019 || Revit2020
elevation_Bottom = UnitUtils.ConvertFromInternalUnits(boundingBoxXYZ.Min.Z, DisplayUnitType.DUT_METERS);
#else
elevation_Bottom = UnitUtils.ConvertFromInternalUnits(boundingBoxXYZ.Min.Z, UnitTypeId.Meters);
#endif
}
if (double.IsNaN(elevation_Bottom))
{
ElementId elementId = space.LevelId;
if (elementId != null && elementId != ElementId.InvalidElementId)
{
Level level = document.GetElement(elementId) as Level;
#if Revit2017 || Revit2018 || Revit2019 || Revit2020
elevation_Bottom = UnitUtils.ConvertFromInternalUnits(level.Elevation, DisplayUnitType.DUT_METERS);
#else
elevation_Bottom = UnitUtils.ConvertFromInternalUnits(level.Elevation, UnitTypeId.Meters);
#endif
}
}
Point3D point3D = Geometry.Revit.Convert.ToSAM(xyz);
if (point3D == null)
{
continue;
}
Geometry.Planar.Point2D point2D = Geometry.Spatial.Plane.WorldXY.Convert(point3D);
if (point2D == null)
{
continue;
}
#if Revit2017 || Revit2018 || Revit2019 || Revit2020
cutElevations.Add(UnitUtils.ConvertToInternalUnits(elevation_Bottom + offset, DisplayUnitType.DUT_METERS));
#else
cutElevations.Add(UnitUtils.ConvertToInternalUnits(elevation_Bottom + offset, UnitTypeId.Meters));
#endif
if (!dictionary.TryGetValue(elevation_Bottom, out List <Tuple <double, Geometry.Planar.Point2D, Autodesk.Revit.DB.Mechanical.Space> > tuples))
{
tuples = new List <Tuple <double, Geometry.Planar.Point2D, Autodesk.Revit.DB.Mechanical.Space> >();
dictionary[elevation_Bottom] = tuples;
}
tuples.Add(new Tuple <double, Geometry.Planar.Point2D, Autodesk.Revit.DB.Mechanical.Space>(elevation_Top, point2D, space));
}
//Collecting Revit Walls
List <Autodesk.Revit.DB.Wall> walls = new FilteredElementCollector(document).OfClass(typeof(Autodesk.Revit.DB.Wall)).Cast <Autodesk.Revit.DB.Wall>().ToList();
if (walls == null || walls.Count == 0)
{
return(null);
}
//Converting Revit Walls to SAM Panels
List <Panel> panels = new List <Panel>();
foreach (Autodesk.Revit.DB.Wall wall in walls)
{
BoundingBoxXYZ boundingBoxXYZ = wall?.get_BoundingBox(null);
if (boundingBoxXYZ == null)
{
continue;
}
bool valid = false;
foreach (double cutElevation in cutElevations)
{
if (boundingBoxXYZ.Max.Z >= cutElevation && boundingBoxXYZ.Min.Z <= cutElevation)
{
valid = true;
break;
}
}
if (!valid)
{
continue;
}
List <Panel> panels_Wall = wall.ToSAM(new Core.Revit.ConvertSettings(true, false, false));
if (panels_Wall == null || panels_Wall.Count == 0)
{
continue;
}
panels.AddRange(panels_Wall);
}
if (panels == null || panels.Count == 0)
{
return(null);
}
List <Shell> result = new List <Shell>();
//Inerating through elevations and Spaces data
foreach (KeyValuePair <double, List <Tuple <double, Geometry.Planar.Point2D, Autodesk.Revit.DB.Mechanical.Space> > > keyValuePair in dictionary)
{
double elevation_Bottom = keyValuePair.Key;
double elevation_Cut = elevation_Bottom + offset;
Geometry.Spatial.Plane plane_Cut = Geometry.Spatial.Plane.WorldXY.GetMoved(new Vector3D(0, 0, elevation_Cut)) as Geometry.Spatial.Plane;
List <Geometry.Planar.Segment2D> segment2Ds = new List <Geometry.Planar.Segment2D>();
foreach (Panel panel in panels)
{
IClosedPlanar3D closedPlanar3D = panel?.GetFace3D()?.GetExternalEdge3D();
if (closedPlanar3D == null)
{
continue;
}
PlanarIntersectionResult planarIntersectionResult = plane_Cut.PlanarIntersectionResult(closedPlanar3D);
if (planarIntersectionResult == null || !planarIntersectionResult.Intersecting)
{
continue;
}
List <Geometry.Planar.ISegmentable2D> segmentable2Ds_Temp = planarIntersectionResult.GetGeometry2Ds <Geometry.Planar.ISegmentable2D>();
if (segmentable2Ds_Temp == null || segmentable2Ds_Temp.Count == 0)
{
continue;
}
segmentable2Ds_Temp?.ForEach(x => segment2Ds.AddRange(x.GetSegments()));
}
if (panels == null || panels.Count == 0)
{
continue;
}
segment2Ds = Geometry.Planar.Query.Split(segment2Ds, tolerance);
segment2Ds = Geometry.Planar.Query.Snap(segment2Ds, true, snapTolerance);
List <Tuple <Geometry.Planar.BoundingBox2D, Geometry.Planar.Polygon2D> > tuples_Polygon2D = Geometry.Planar.Create.Polygon2Ds(segment2Ds)?.ConvertAll(x => new Tuple <Geometry.Planar.BoundingBox2D, Geometry.Planar.Polygon2D>(x.GetBoundingBox(tolerance), x));
if (tuples_Polygon2D == null || tuples_Polygon2D.Count == 0)
{
continue;
}
Geometry.Spatial.Plane plane_Bottom = Geometry.Spatial.Plane.WorldXY.GetMoved(new Vector3D(0, 0, elevation_Bottom)) as Geometry.Spatial.Plane;
List <Tuple <double, Geometry.Planar.Point2D, Autodesk.Revit.DB.Mechanical.Space> > tuples_Space = keyValuePair.Value;
while (tuples_Space.Count > 0)
{
Tuple <double, Geometry.Planar.Point2D, Autodesk.Revit.DB.Mechanical.Space> tuple = tuples_Space[0];
tuples_Space.RemoveAt(0);
Geometry.Spatial.Plane plane_Top = Geometry.Spatial.Plane.WorldXY.GetMoved(new Vector3D(0, 0, tuple.Item1)) as Geometry.Spatial.Plane;
Geometry.Planar.Point2D point2D = tuple.Item2;
List <Tuple <Geometry.Planar.BoundingBox2D, Geometry.Planar.Polygon2D> > tuples_Polygon2D_External = tuples_Polygon2D.FindAll(x => x.Item1.Inside(point2D, tolerance)).FindAll(x => x.Item2.Inside(point2D, tolerance));
tuples_Polygon2D_External.Sort((x, y) => x.Item1.GetArea().CompareTo(y.Item1.GetArea()));
Tuple <Geometry.Planar.BoundingBox2D, Geometry.Planar.Polygon2D> tuple_Polygon2D_External = tuples_Polygon2D_External.FirstOrDefault();
if (tuple_Polygon2D_External == null)
{
continue;
}
List <Tuple <Geometry.Planar.BoundingBox2D, Geometry.Planar.Polygon2D> > tuples_Polygon2D_Internal = new List <Tuple <Geometry.Planar.BoundingBox2D, Geometry.Planar.Polygon2D> >();
foreach (Tuple <Geometry.Planar.BoundingBox2D, Geometry.Planar.Polygon2D> tuple_Polygon2D in tuples_Polygon2D)
{
if (tuple_Polygon2D == tuple_Polygon2D_External)
{
continue;
}
if (tuple_Polygon2D_External.Item1.Inside(tuple_Polygon2D.Item1, tolerance) && tuple_Polygon2D_External.Item2.Inside(tuple_Polygon2D.Item2, tolerance))
{
tuples_Polygon2D_Internal.Add(tuple_Polygon2D);
}
}
List <Geometry.Planar.Face2D> face2Ds = Geometry.Planar.Query.Difference(new Geometry.Planar.Face2D(tuple_Polygon2D_External.Item2), tuples_Polygon2D_Internal.ConvertAll(x => new Geometry.Planar.Face2D(x.Item2)), tolerance);
if (face2Ds == null || face2Ds.Count == 0)
{
continue;
}
foreach (Geometry.Planar.Face2D face2D in face2Ds)
{
tuples_Space.RemoveAll(x => face2D.Inside(x.Item2, tolerance));
}
List <Face3D> face3Ds = new List <Face3D>();
face3Ds.AddRange(face2Ds.ConvertAll(x => new Face3D(plane_Bottom, x)));
face3Ds.AddRange(face2Ds.ConvertAll(x => new Face3D(plane_Top, x)));
List <Shell> shells_Temp = Geometry.Spatial.Create.Shells(face3Ds, new double[] { elevation_Bottom }, offset, snapTolerance: snapTolerance, tolerance_Distance: tolerance);
if (shells_Temp == null || shells_Temp.Count == 0)
{
continue;
}
result.AddRange(shells_Temp);
}
}
return(result);
}
public static List <Line> ToRevit(this IClosedPlanar3D closedPlanar3D, double tolerance_Distance = Core.Tolerance.Distance, double tolerance_Angle = Core.Tolerance.Angle)
{
return(Query.Segment3Ds(closedPlanar3D, tolerance_Distance, tolerance_Angle)?.ConvertAll(x => x.ToRevit_Line()));
}
public static Aperture ToSAM_Aperture(this FamilyInstance familyInstance, Core.Revit.ConvertSettings convertSettings)
{
if (familyInstance == null)
{
return(null);
}
Aperture result = convertSettings?.GetObject <Aperture>(familyInstance.Id);
if (result != null)
{
return(result);
}
if (Core.Revit.Query.Simplified(familyInstance))
{
result = Core.Revit.Query.IJSAMObject <Aperture>(familyInstance);
if (result != null)
{
convertSettings?.Add(familyInstance.Id, result);
return(result);
}
}
Point3D point3D_Location = Geometry.Revit.Query.Location(familyInstance);
if (point3D_Location == null)
{
return(null);
}
PanelType panelType_Host = PanelType.Undefined;
BuiltInCategory builtInCategory_Host = BuiltInCategory.INVALID;
if (familyInstance.Host != null)
{
HostObject hostObject = familyInstance.Host as HostObject;
if (hostObject != null)
{
builtInCategory_Host = (BuiltInCategory)hostObject.Category.Id.IntegerValue;
List <Face3D> face3Ds_Temp = hostObject.Profiles();
if (face3Ds_Temp != null && face3Ds_Temp.Count != 0)
{
Geometry.Spatial.Plane plane_Host = face3Ds_Temp.Closest(point3D_Location)?.GetPlane();
if (plane_Host != null)
{
point3D_Location = plane_Host.Project(point3D_Location);
}
}
HostObjAttributes hostObjAttributes = familyInstance.Document.GetElement(hostObject.GetTypeId()) as HostObjAttributes;
if (hostObjAttributes != null)
{
panelType_Host = hostObjAttributes.PanelType();
}
if (panelType_Host == PanelType.Undefined)
{
panelType_Host = hostObject.PanelType();
}
}
}
ApertureConstruction apertureConstruction = ToSAM_ApertureConstruction(familyInstance, convertSettings);
if (apertureConstruction == null && panelType_Host != PanelType.Undefined)
{
apertureConstruction = Analytical.Query.DefaultApertureConstruction(panelType_Host, familyInstance.ApertureType()); //Default Aperture Construction
}
Vector3D axisX = null;
Vector3D normal = null;
Vector3D axisY = null;
if (builtInCategory_Host == BuiltInCategory.OST_Roofs)
{
axisX = familyInstance.HandOrientation.ToSAM_Vector3D(false);
axisY = familyInstance.FacingOrientation.ToSAM_Vector3D(false);
normal = Geometry.Spatial.Query.AxisY(axisY, axisX);
}
else
{
axisX = familyInstance.HandOrientation.ToSAM_Vector3D(false);
normal = familyInstance.FacingOrientation.ToSAM_Vector3D(false);
axisY = Geometry.Spatial.Query.AxisY(normal, axisX);
}
Geometry.Spatial.Plane plane = Geometry.Spatial.Create.Plane(point3D_Location, axisX, axisY);
if (!plane.Normal.SameHalf(normal))
{
plane.FlipZ(false);
}
List <Face3D> face3Ds = Geometry.Revit.Convert.ToSAM_Face3Ds(familyInstance);
if (face3Ds == null || face3Ds.Count == 0)
{
return(null);
}
List <Point2D> point2Ds = new List <Point2D>();
foreach (Face3D face3D_Temp in face3Ds)
{
IClosedPlanar3D closedPlanar3D = face3D_Temp.GetExternalEdge3D();
if (closedPlanar3D is ICurvable3D)
{
List <ICurve3D> curve3Ds = ((ICurvable3D)closedPlanar3D).GetCurves();
foreach (ICurve3D curve3D in curve3Ds)
{
ICurve3D curve3D_Temp = plane.Project(curve3D);
point2Ds.Add(plane.Convert(curve3D_Temp.GetStart()));
}
}
}
if (point2Ds == null || point2Ds.Count == 0)
{
return(null);
}
//TODO: Working on SAM Families (requested by Michal)
string parameterName_Height = Core.Revit.Query.Name(ActiveSetting.Setting, typeof(Aperture), typeof(FamilyInstance), "GetHeight");
string parameterName_Width = Core.Revit.Query.Name(ActiveSetting.Setting, typeof(Aperture), typeof(FamilyInstance), "GetWidth");
if (!string.IsNullOrWhiteSpace(parameterName_Height) && !string.IsNullOrWhiteSpace(parameterName_Width))
{
Parameter parameter_Height = familyInstance.LookupParameter(parameterName_Height);
Parameter parameter_Width = familyInstance.LookupParameter(parameterName_Width);
if (parameter_Height != null && parameter_Width != null && parameter_Height.HasValue && parameter_Width.HasValue && parameter_Height.StorageType == StorageType.Double && parameter_Width.StorageType == StorageType.Double)
{
double height = UnitUtils.ConvertFromInternalUnits(parameter_Height.AsDouble(), DisplayUnitType.DUT_METERS);
double width = UnitUtils.ConvertFromInternalUnits(parameter_Width.AsDouble(), DisplayUnitType.DUT_METERS);
BoundingBox2D boundingBox2D = new BoundingBox2D(point2Ds);
double factor_Height = height / boundingBox2D.Height;
double factor_Width = width / boundingBox2D.Width;
point2Ds = point2Ds.ConvertAll(x => new Point2D(x.X * factor_Width, x.Y * factor_Height));
}
}
Rectangle2D rectangle2D = Geometry.Planar.Create.Rectangle2D(point2Ds);
result = new Aperture(apertureConstruction, new Face3D(plane, rectangle2D));
result.UpdateParameterSets(familyInstance, ActiveSetting.Setting.GetValue <Core.TypeMap>(Core.Revit.ActiveSetting.Name.ParameterMap));
convertSettings?.Add(familyInstance.Id, result);
return(result);
}
public static IOpening ToSAM_Opening(this FamilyInstance familyInstance, ConvertSettings convertSettings)
{
if (familyInstance == null)
{
return(null);
}
IOpening result = convertSettings?.GetObject <IOpening>(familyInstance.Id);
if (result != null)
{
return(result);
}
if (Core.Revit.Query.Simplified(familyInstance))
{
result = Core.Revit.Query.IJSAMObjects <IOpening>(familyInstance)?.FirstOrDefault();
if (result != null)
{
convertSettings?.Add(familyInstance.Id, result);
return(result);
}
}
Point3D point3D_Location = Geometry.Revit.Query.LocationPoint3D(familyInstance);
if (point3D_Location == null)
{
List <Solid> solids = Core.Revit.Query.Solids(familyInstance, new Options());
solids?.RemoveAll(x => x.Volume == 0);
if (solids == null || solids.Count == 0)
{
return(null);
}
if (solids.Count > 1)
{
solids.Sort((x, y) => y.Volume.CompareTo(x.Volume));
}
point3D_Location = solids[0].ComputeCentroid()?.ToSAM();
}
if (point3D_Location == null)
{
return(null);
}
OpeningType openingType = ToSAM_OpeningType(familyInstance.Symbol, convertSettings);
if (openingType == null)
{
return(null);
}
BuiltInCategory builtInCategory_Host = BuiltInCategory.INVALID;
HostObject hostObject = familyInstance.Host as HostObject;
if (hostObject != null)
{
builtInCategory_Host = (BuiltInCategory)hostObject.Category.Id.IntegerValue;
}
Vector3D axisX = null;
Vector3D normal = null;
Vector3D axisY = null;
if (builtInCategory_Host == BuiltInCategory.OST_Roofs)
{
axisX = familyInstance.HandOrientation.ToSAM_Vector3D(false);
axisY = familyInstance.FacingOrientation.ToSAM_Vector3D(false);
normal = Geometry.Spatial.Query.AxisY(axisY, axisX);
}
else
{
axisX = familyInstance.HandOrientation.ToSAM_Vector3D(false);
normal = familyInstance.FacingOrientation.ToSAM_Vector3D(false);
axisY = Geometry.Spatial.Query.AxisY(normal, axisX);
}
Geometry.Spatial.Plane plane = Geometry.Spatial.Create.Plane(point3D_Location, axisX, axisY);
if (!plane.Normal.SameHalf(normal))
{
plane.FlipZ(false);
}
List <Face3D> face3Ds = Geometry.Revit.Convert.ToSAM_Geometries <Face3D>(familyInstance);
if (face3Ds == null || face3Ds.Count == 0)
{
return(null);
}
List <Point2D> point2Ds = new List <Point2D>();
foreach (Face3D face3D_Temp in face3Ds)
{
IClosedPlanar3D closedPlanar3D = face3D_Temp.GetExternalEdge3D();
if (closedPlanar3D is ICurvable3D)
{
List <ICurve3D> curve3Ds = ((ICurvable3D)closedPlanar3D).GetCurves();
foreach (ICurve3D curve3D in curve3Ds)
{
ICurve3D curve3D_Temp = plane.Project(curve3D);
point2Ds.Add(plane.Convert(curve3D_Temp.GetStart()));
}
}
}
if (point2Ds == null || point2Ds.Count == 0)
{
return(null);
}
Rectangle2D rectangle2D = Geometry.Planar.Create.Rectangle2D(point2Ds);
result = Analytical.Create.Opening(openingType, new Face3D(plane, rectangle2D));
result.UpdateParameterSets(familyInstance);
convertSettings?.Add(familyInstance.Id, result);
return(result);
}
public static TBD.Perimeter ToTBD(this Face3D face3D, TBD.RoomSurface roomSurface = null)
{
if (face3D == null)
{
return(null);
}
IClosedPlanar3D externalEdge3D = face3D.GetExternalEdge3D();
if (externalEdge3D == null)
{
return(null);
}
ISegmentable3D segmentable3D = externalEdge3D as ISegmentable3D;
if (segmentable3D == null)
{
throw new System.NotImplementedException();
}
TBD.Perimeter result = roomSurface?.CreatePerimeter();
if (result == null)
{
result = new TBD.Perimeter();
}
TBD.Polygon polygon = result.CreateFace();
List <Point3D> point3Ds = segmentable3D.GetPoints();
if (point3Ds != null)
{
foreach (Point3D point3D in point3Ds)
{
if (point3D == null)
{
continue;
}
polygon.AddCoordinate(System.Convert.ToSingle(point3D.X), System.Convert.ToSingle(point3D.Y), System.Convert.ToSingle(point3D.Z));
}
}
List <IClosedPlanar3D> internalEdge3Ds = face3D.GetInternalEdge3Ds();
if (internalEdge3Ds != null && internalEdge3Ds.Count != 0)
{
foreach (IClosedPlanar3D closedPlanar3D in internalEdge3Ds)
{
if (closedPlanar3D == null)
{
continue;
}
segmentable3D = closedPlanar3D as ISegmentable3D;
if (segmentable3D == null)
{
throw new System.NotImplementedException();
}
polygon = result.AddHole();
point3Ds = segmentable3D.GetPoints();
if (point3Ds != null)
{
foreach (Point3D point3D in point3Ds)
{
if (point3D == null)
{
continue;
}
polygon.AddCoordinate(System.Convert.ToSingle(point3D.X), System.Convert.ToSingle(point3D.Y), System.Convert.ToSingle(point3D.Z));
}
}
}
}
return(result);
}