public static Aperture ToSAM(this HoneybeeSchema.Aperture aperture, bool @internal, IEnumerable <ApertureConstruction> apertureConstructions = null)
{
if (aperture == null)
{
return(null);
}
Geometry.Spatial.Face3D face3D = Geometry.LadybugTools.Convert.ToSAM(aperture.Geometry);
if (face3D == null)
{
return(null);
}
ApertureConstruction apertureConstruction = null;
if (apertureConstructions != null && aperture.Properties?.Energy?.Construction != null)
{
foreach (ApertureConstruction apertureConstruction_Temp in apertureConstructions)
{
if (apertureConstruction_Temp == null)
{
continue;
}
if (apertureConstruction_Temp.ApertureType != ApertureType.Window)
{
continue;
}
if (aperture.Properties.Energy.Construction == apertureConstruction_Temp.Name)
{
apertureConstruction = apertureConstruction_Temp;
break;
}
}
}
if (apertureConstruction == null)
{
AnyOf <OpaqueConstructionAbridged, WindowConstructionAbridged, ShadeConstruction, AirBoundaryConstructionAbridged> construction_Honeybee = Query.DefaultApertureConstruction(ApertureType.Window, @internal);
if (construction_Honeybee != null)
{
apertureConstruction = construction_Honeybee.ToSAM_ApertureConstruction();
}
}
if (apertureConstruction == null)
{
apertureConstruction = new ApertureConstruction(aperture.DisplayName, ApertureType.Window);
}
Aperture result = new Aperture(apertureConstruction, face3D, Analytical.Query.OpeningLocation(face3D));
return(result);
}
public static Panel SimilarPanel(this Geometry.Spatial.Face3D face3D, Dictionary <Panel, Geometry.Spatial.Face3D> panelsDictionary, double distanceTolerance = Core.Tolerance.MacroDistance, double coplanarTolerance = Core.Tolerance.MacroDistance)
{
if (face3D == null || panelsDictionary == null)
{
return(null);
}
Geometry.Spatial.Plane plane = face3D.GetPlane();
double area = face3D.GetArea();
Geometry.Planar.IClosed2D closed2D_1 = Geometry.Spatial.Query.Convert(plane, face3D.GetExternalEdge3D());
Geometry.Planar.Point2D point2D_Internal = closed2D_1.GetInternalPoint2D();
double areaDifferece_Min = double.MaxValue;
Panel result = null;
foreach (KeyValuePair <Panel, Geometry.Spatial.Face3D> keyValuePair in panelsDictionary)
{
if (keyValuePair.Value == null)
{
continue;
}
double areaDifference = System.Math.Abs(keyValuePair.Value.GetArea() - area);
if (areaDifferece_Min < areaDifference)
{
continue;
}
Geometry.Spatial.Face3D face3D_Temp = keyValuePair.Value;
Geometry.Spatial.Plane plane_Temp = face3D_Temp.GetPlane();
if (!plane.Coplanar(plane_Temp, coplanarTolerance))
{
continue;
}
Geometry.Spatial.Point3D point3D_Origin = plane_Temp.Origin;
Geometry.Spatial.Point3D point3D_Project = Geometry.Spatial.Query.Project(plane, point3D_Origin);
if (point3D_Origin.Distance(point3D_Project) > distanceTolerance)
{
continue;
}
Geometry.Planar.IClosed2D closed2D_2 = Geometry.Spatial.Query.Convert(plane, face3D_Temp.GetExternalEdge3D());
if (closed2D_2.Inside(point2D_Internal))
{
result = keyValuePair.Key;
areaDifferece_Min = areaDifference;
}
}
return(result);
}
public static Panel ToSAM(this Shade shade, IEnumerable <Construction> constructions = null)
{
if (shade == null)
{
return(null);
}
Geometry.Spatial.Face3D face3D = Geometry.LadybugTools.Convert.ToSAM(shade.Geometry);
if (face3D == null)
{
return(null);
}
Construction construction = null;
if (constructions != null && shade.Properties?.Energy?.Construction != null)
{
foreach (Construction construction_Temp in constructions)
{
if (construction_Temp.Name == shade.Properties.Energy.Construction)
{
construction = construction_Temp;
break;
}
}
}
if (construction == null)
{
AnyOf <OpaqueConstructionAbridged, WindowConstructionAbridged, ShadeConstruction, AirBoundaryConstructionAbridged> construction_Honeybee = Query.DefaultConstruction(PanelType.Shade);
if (construction_Honeybee != null)
{
construction = construction_Honeybee.ToSAM_Construction();
}
}
if (construction == null)
{
construction = new Construction(shade.Identifier);
}
return(Create.Panel(construction, PanelType.Shade, face3D));
}
public static PlanarGeometry TogbXML(this PlanarBoundary3D planarBoundary3D, double tolerance = Core.Tolerance.MicroDistance)
{
if (planarBoundary3D == null)
{
return(null);
}
Geometry.Spatial.Face3D face3D = planarBoundary3D.GetFace3D();
if (face3D == null)
{
return(null);
}
PlanarGeometry planarGeometry = new PlanarGeometry();
planarGeometry.PolyLoop = face3D.TogbXML_PolyLoop(tolerance);
return(planarGeometry);
}
public static SpaceBoundary TogbXML_SpaceBoundary(this Panel panel, double tolerance = Core.Tolerance.MicroDistance)
{
if (panel == null)
{
return(null);
}
Geometry.Spatial.Face3D face3D = panel.PlanarBoundary3D.GetFace3D();
if (face3D == null)
{
return(null);
}
SpaceBoundary spaceBoundary = new SpaceBoundary();
spaceBoundary.surfaceIdRef = Core.gbXML.Query.Id(panel, typeof(Surface));
spaceBoundary.PlanarGeometry = face3D.TogbXML(tolerance);
return(spaceBoundary);
}
public static PlanarBoundary3D Transform(this Transform transform, PlanarBoundary3D planarBoundary3D)
{
if (transform == null || planarBoundary3D == null)
{
return(null);
}
if (transform.IsIdentity)
{
return(new PlanarBoundary3D(planarBoundary3D));
}
Geometry.Spatial.Face3D face3D = planarBoundary3D.GetFace3D();
if (face3D == null || !Geometry.Spatial.Query.IsValid(face3D))
{
return(null);
}
return(new PlanarBoundary3D(Geometry.Revit.Query.Transform(transform, face3D)));
}
public static Face ToTopologic(this Panel panel)
{
if (panel == null)
{
return(null);
}
Geometry.Spatial.Face3D face3D = panel.GetFace3D();
if (face3D == null)
{
return(null);
}
Wire externalWire = Geometry.Topologic.Convert.ToTopologic(face3D.GetExternalEdge3D() as Geometry.Spatial.ICurvable3D);
if (externalWire == null)
{
return(null);
}
List <Wire> internalWires = new List <Wire>();
List <Geometry.Spatial.IClosedPlanar3D> internalClosedPlanar3Ds = face3D.GetInternalEdge3Ds();
if (internalClosedPlanar3Ds != null && internalClosedPlanar3Ds.Count > 0)
{
foreach (Geometry.Spatial.IClosedPlanar3D closedPlanar3D in internalClosedPlanar3Ds)
{
Wire internalWire = Geometry.Topologic.Convert.ToTopologic(closedPlanar3D as Geometry.Spatial.ICurvable3D);
if (internalWire != null)
{
internalWires.Add(internalWire);
}
}
}
return(Face.ByExternalInternalBoundaries(externalWire, internalWires));
}
/// <summary>
/// Gets Wall Panels from Spatial Element base on its Boundary
/// </summary>
/// <param name="spatialElement">Revit Spatial Element such as Space or Room</param>
/// <param name="elevation_Bottom">Bottom Elevation</param>
/// <param name="elevation_Top">Top Elevation</param>
/// <param name="convertSettings">Convert Settings</param>
/// <param name="spatialElementBoundaryOptions">Revit SpactialElementBoundaryOptions. Center Spatial Element Boundary Location will be used when set to null</param>
/// <returns>Wall Panels</returns>
public static List <Panel> Panels(this SpatialElement spatialElement, double elevation_Bottom, double elevation_Top, Core.Revit.ConvertSettings convertSettings, SpatialElementBoundaryOptions spatialElementBoundaryOptions = null)
{
if (spatialElement == null || double.IsNaN(elevation_Top) || double.IsNaN(elevation_Bottom))
{
return(null);
}
if (spatialElementBoundaryOptions == null)
{
spatialElementBoundaryOptions = new SpatialElementBoundaryOptions();
spatialElementBoundaryOptions.SpatialElementBoundaryLocation = SpatialElementBoundaryLocation.Center;
}
Document document = spatialElement.Document;
Geometry.Spatial.Plane plane = Geometry.Spatial.Plane.WorldXY;
Geometry.Spatial.Plane plane_Top = plane.GetMoved(new Geometry.Spatial.Vector3D(0, 0, elevation_Top)) as Geometry.Spatial.Plane;
Geometry.Spatial.Plane plane_Bottom = plane.GetMoved(new Geometry.Spatial.Vector3D(0, 0, elevation_Bottom)) as Geometry.Spatial.Plane;
List <Panel> panels = new List <Panel>();
IList <IList <BoundarySegment> > boundaries = spatialElement.GetBoundarySegments(spatialElementBoundaryOptions);
foreach (IList <BoundarySegment> boundarySegments in boundaries)
{
if (boundarySegments == null)
{
continue;
}
foreach (BoundarySegment boundarySegment in boundarySegments)
{
if (boundarySegment == null)
{
continue;
}
Curve curve = boundarySegment.GetCurve();
if (curve == null)
{
continue;
}
HostObject hostObject = null;
if (boundarySegment.ElementId != null && boundarySegment.ElementId != ElementId.InvalidElementId)
{
if (boundarySegment.LinkElementId == null || boundarySegment.LinkElementId == ElementId.InvalidElementId)
{
hostObject = document.GetElement(boundarySegment.ElementId) as HostObject;
}
else
{
RevitLinkInstance revitLinkInstance = document.GetElement(boundarySegment.LinkElementId) as RevitLinkInstance;
if (revitLinkInstance != null)
{
Document document_Linked = revitLinkInstance.GetLinkDocument();
if (document_Linked != null)
{
hostObject = document_Linked.GetElement(boundarySegment.ElementId) as HostObject;
}
}
}
}
Panel panel_Temp = null;
if (hostObject != null)
{
List <Panel> panels_Temp = hostObject.ToSAM(convertSettings);
if (panels_Temp != null && panels_Temp.Count > 0)
{
panel_Temp = panels_Temp[0];
}
}
List <Geometry.Spatial.Segment3D> segment3Ds = Geometry.Revit.Convert.ToSAM_Segment3Ds(curve);
if (segment3Ds == null || segment3Ds.Count == 0)
{
continue;
}
foreach (Geometry.Spatial.Segment3D segment3D in segment3Ds)
{
Geometry.Spatial.Segment3D segment3D_Top = Geometry.Spatial.Query.Project(plane_Top, segment3D);
Geometry.Spatial.Segment3D segment3D_Bottom = Geometry.Spatial.Query.Project(plane_Bottom, segment3D);
Geometry.Spatial.Polygon3D polygon3D = Geometry.Spatial.Create.Polygon3D(new Geometry.Spatial.Point3D[] { segment3D_Top[0], segment3D_Top[1], segment3D_Bottom[1], segment3D_Bottom[0] });
if (polygon3D == null)
{
continue;
}
Geometry.Spatial.Face3D face3D = new Geometry.Spatial.Face3D(polygon3D);
Panel panel = null;
if (panel_Temp != null)
{
panel = Analytical.Create.Panel(Guid.NewGuid(), panel_Temp, face3D);
}
if (panel_Temp != null)
{
Geometry.Spatial.Vector3D normal = polygon3D.GetPlane()?.Normal;
PanelType panelType = Analytical.Query.PanelType(normal);
Construction construction = Query.DefaultAirConstruction(panelType.PanelGroup());
panel = Analytical.Create.Panel(construction, panelType, face3D);
}
if (panel != null)
{
panels.Add(panel);
}
}
}
}
return(panels);
}
public static HostObject ToRevit(this Panel panel, Document document, Core.Revit.ConvertSettings convertSettings)
{
Geometry.Spatial.Face3D face3D = panel?.GetFace3D();
if (face3D == null)
{
return(null);
}
HostObject result = convertSettings?.GetObject <HostObject>(panel.Guid);
if (result != null)
{
return(result);
}
PanelType panelType = panel.PanelType;
Geometry.Spatial.Vector3D normal = panel.Normal;
HostObjAttributes hostObjAttributes = panel.Construction.ToRevit(document, panelType, normal, convertSettings);
if (hostObjAttributes == null)
{
hostObjAttributes = Analytical.Query.DefaultConstruction(panelType)?.ToRevit(document, panelType, normal, convertSettings); //Default Construction
}
BuiltInParameter[] builtInParameters = null;
if (hostObjAttributes is Autodesk.Revit.DB.WallType)
{
double lowElevation = panel.LowElevation();
Level level = document.LowLevel(lowElevation);
Autodesk.Revit.DB.Wall wall = ToRevit_Wall(face3D, document, (Autodesk.Revit.DB.WallType)hostObjAttributes, level);
if (wall == null)
{
return(result);
}
//List<Curve> curveList = new List<Curve>();
//foreach (Geometry.Spatial.IClosedPlanar3D closedPlanar3D in face3D.GetEdge3Ds())
//{
// if (Geometry.Spatial.Query.Clockwise(closedPlanar3D))
// closedPlanar3D.Reverse();
// List<Line> lines = closedPlanar3D.ToRevit();
// if (lines == null)
// continue;
// curveList.AddRange(lines);
//}
//if (curveList == null || curveList.Count == 0)
// return null;
//double lowElevation = panel.LowElevation();
//Level level = document.LowLevel(lowElevation);
//if (level == null)
// return null;
//Wall wall = Wall.Create(document, curveList, hostObjAttributes.Id, level.Id, false, panel.Normal.ToRevit(false));
Parameter parameter = null;
parameter = wall.get_Parameter(BuiltInParameter.WALL_HEIGHT_TYPE);
if (parameter != null)
{
parameter.Set(ElementId.InvalidElementId);
}
parameter = wall.get_Parameter(BuiltInParameter.WALL_USER_HEIGHT_PARAM);
if (parameter != null)
{
#if Revit2017 || Revit2018 || Revit2019 || Revit2020
double height = UnitUtils.ConvertToInternalUnits((panel.HighElevation() - lowElevation), DisplayUnitType.DUT_METERS);
#else
double height = UnitUtils.ConvertToInternalUnits((panel.HighElevation() - lowElevation), UnitTypeId.Meters);
#endif
parameter.Set(height);
}
#if Revit2017 || Revit2018 || Revit2019 || Revit2020
double levelElevation = UnitUtils.ConvertFromInternalUnits(level.Elevation, DisplayUnitType.DUT_METERS);
#else
double levelElevation = UnitUtils.ConvertFromInternalUnits(level.Elevation, UnitTypeId.Meters);
#endif
if (Math.Abs(lowElevation - levelElevation) > Core.Tolerance.MacroDistance)
{
parameter = wall.get_Parameter(BuiltInParameter.WALL_BASE_OFFSET);
if (parameter != null)
{
#if Revit2017 || Revit2018 || Revit2019 || Revit2020
parameter.Set(UnitUtils.ConvertToInternalUnits(lowElevation - levelElevation, DisplayUnitType.DUT_METERS));
#else
parameter.Set(UnitUtils.ConvertToInternalUnits(lowElevation - levelElevation, UnitTypeId.Meters));
#endif
}
}
builtInParameters = new BuiltInParameter[] { BuiltInParameter.WALL_BASE_CONSTRAINT, BuiltInParameter.WALL_BASE_OFFSET, BuiltInParameter.WALL_HEIGHT_TYPE, BuiltInParameter.WALL_USER_HEIGHT_PARAM, BuiltInParameter.WALL_KEY_REF_PARAM };
result = wall;
}
else if (hostObjAttributes is Autodesk.Revit.DB.FloorType)
{
Geometry.Spatial.IClosedPlanar3D closedPlanar3D_External = face3D.GetExternalEdge3D();
if (!(closedPlanar3D_External is Geometry.Spatial.ICurvable3D))
{
return(null);
}
double elevation = panel.LowElevation();
Level level = document.HighLevel(elevation);
Geometry.Spatial.Plane plane = new Geometry.Spatial.Plane(new Geometry.Spatial.Point3D(0, 0, elevation), Geometry.Spatial.Vector3D.WorldZ);
CurveArray curveArray_Sloped = new CurveArray();
CurveArray curveArray_Plane = new CurveArray();
Geometry.Spatial.IClosedPlanar3D closedPlanar3D = face3D.GetExternalEdge3D();
if (!(closedPlanar3D is Geometry.Spatial.ICurvable3D))
{
return(null);
}
List <Geometry.Spatial.Segment3D> segment3Ds = Geometry.Revit.Query.Segment3Ds(closedPlanar3D);
if (segment3Ds == null || segment3Ds.Count == 0)
{
return(null);
}
foreach (Geometry.Spatial.Segment3D segment3D in segment3Ds)
{
curveArray_Sloped.Append(segment3D.ToRevit_Line());
Geometry.Spatial.Segment3D segment3D_Temp = Geometry.Spatial.Query.Project(plane, segment3D);
if (segment3D_Temp == null)
{
continue;
}
curveArray_Plane.Append(segment3D_Temp.ToRevit_Line());
}
#if Revit2017 || Revit2018 || Revit2019 || Revit2020 || Revit2021
Autodesk.Revit.DB.Floor floor = document.Create.NewFloor(curveArray_Plane, hostObjAttributes as Autodesk.Revit.DB.FloorType, level, false);
#else
CurveLoop curveLoop = new CurveLoop();
foreach (Curve curve in curveArray_Plane)
{
curveLoop.Append(curve);
}
Autodesk.Revit.DB.Floor floor = Autodesk.Revit.DB.Floor.Create(document, new CurveLoop[] { curveLoop }, hostObjAttributes.Id, level.Id);
#endif
if (floor != null)
{
floor.ChangeTypeId(hostObjAttributes.Id);
List <Geometry.Spatial.IClosedPlanar3D> closedPlanar3Ds_Internal = face3D.GetInternalEdge3Ds();
if (closedPlanar3Ds_Internal != null && closedPlanar3Ds_Internal.Count > 0)
{
//Requires to be regenerated before inserting openings
//https://thebuildingcoder.typepad.com/blog/2013/07/create-a-floor-with-an-opening-or-complex-boundary.html
document.Regenerate();
foreach (Geometry.Spatial.IClosedPlanar3D closedPlanar3D_Internal in face3D.GetInternalEdge3Ds())
{
List <Geometry.Spatial.Segment3D> segment3Ds_Internal = Geometry.Revit.Query.Segment3Ds(closedPlanar3D_Internal);
if (segment3Ds_Internal == null || segment3Ds_Internal.Count == 0)
{
continue;
}
curveArray_Plane = new CurveArray();
//foreach (Geometry.Spatial.Segment3D segment3D in segment3Ds)
foreach (Geometry.Spatial.Segment3D segment3D in segment3Ds_Internal)
{
curveArray_Sloped.Append(segment3D.ToRevit_Line());
Geometry.Spatial.Segment3D segment3D_Temp = Geometry.Spatial.Query.Project(plane, segment3D);
if (segment3D_Temp == null)
{
continue;
}
curveArray_Plane.Append(segment3D_Temp.ToRevit_Line());
}
Opening opening = document.Create.NewOpening(floor, curveArray_Plane, true);
}
}
}
if (floor != null)
{
document.Regenerate();
SlabShapeEditor slabShapeEditor = floor.SlabShapeEditor;
if (slabShapeEditor != null)
{
slabShapeEditor.ResetSlabShape();
foreach (Curve curve in curveArray_Sloped)
{
XYZ xYZ = curve.GetEndPoint(0);
slabShapeEditor.DrawPoint(xYZ);
}
}
}
builtInParameters = new BuiltInParameter[] { BuiltInParameter.LEVEL_PARAM };
result = floor;
}
else if (hostObjAttributes is Autodesk.Revit.DB.RoofType)
{
CurveArray curveArray = new CurveArray();
foreach (Geometry.Spatial.IClosedPlanar3D closedPlanar3D in face3D.GetEdge3Ds())
{
List <Geometry.Spatial.Segment3D> segment3Ds = Geometry.Revit.Query.Segment3Ds(closedPlanar3D);
if (segment3Ds == null || segment3Ds.Count == 0)
{
return(null);
}
segment3Ds.ForEach(x => curveArray.Append(x.ToRevit_Line()));
}
Level level = document.HighLevel(panel.LowElevation());
double levelElevation = level.Elevation;
ModelCurveArray modelCurveArray = new ModelCurveArray();
RoofBase roofBase = document.Create.NewFootPrintRoof(curveArray, level, hostObjAttributes as Autodesk.Revit.DB.RoofType, out modelCurveArray);
Parameter parameter = roofBase.get_Parameter(BuiltInParameter.ROOF_UPTO_LEVEL_PARAM);
if (parameter != null)
{
parameter.Set(ElementId.InvalidElementId);
}
SlabShapeEditor slabShapeEditor = roofBase.SlabShapeEditor;
if (slabShapeEditor != null)
{
slabShapeEditor.ResetSlabShape();
foreach (Curve curve in curveArray)
{
XYZ xYZ = curve.GetEndPoint(0);
//if (Math.Abs(xYZ.Z - levelElevation) > Core.Tolerance.MicroDistance)
slabShapeEditor.DrawPoint(xYZ);
}
}
builtInParameters = new BuiltInParameter[] { BuiltInParameter.ROOF_LEVEL_OFFSET_PARAM, BuiltInParameter.ROOF_BASE_LEVEL_PARAM, BuiltInParameter.ROOF_UPTO_LEVEL_PARAM };
result = roofBase;
}
if (result == null)
{
return(null);
}
List <Aperture> apertures = panel.Apertures;
if (apertures != null)
{
if (result is Autodesk.Revit.DB.Wall && ((Autodesk.Revit.DB.Wall)result).WallType.Kind == WallKind.Curtain)
{
}
else
{
foreach (Aperture aperture in apertures)
{
Geometry.Spatial.Plane plane_Aperture = aperture?.PlanarBoundary3D?.Plane;
if (plane_Aperture == null)
{
continue;
}
//bool flipHand = !plane_Panel.AxisX.SameHalf(plane_Aperture.AxisX);
//bool flipFacing = !plane_Panel.Normal.SameHalf(plane_Aperture.Normal);
FamilyInstance failyInstance_Aperture = aperture.ToRevit(document, result, convertSettings);
}
}
}
if (convertSettings.ConvertParameters)
{
Core.Revit.Modify.SetValues(result, panel, builtInParameters);
Core.Revit.Modify.SetValues(result, panel, ActiveSetting.Setting);
Core.Revit.Modify.SetJson(result, panel.ToJObject()?.ToString());
}
//TODO: Implement proper log
//System.IO.File.AppendAllText(@"C:\Users\DengusiakM\Desktop\SAM\2020-04-16 floorbug\LOG.txt", string.Format("{0}\t{1}\t{2}\n", DateTime.Now.ToString(), panel.Guid, panel.Name));
convertSettings?.Add(panel.Guid, result);
return(result);
}
public static Panel ToSAM(this Face face, IEnumerable <Construction> constructions = null, IEnumerable <ApertureConstruction> apertureConstructions = null)
{
if (face == null)
{
return(null);
}
Geometry.Spatial.Face3D face3D = Geometry.LadybugTools.Convert.ToSAM(face.Geometry);
if (face3D == null)
{
return(null);
}
PanelType panelType = PanelType.Undefined;
PanelGroup panelGroup = face.FaceType.ToSAM();
Construction construction = null;
if (constructions != null && face.Properties?.Energy?.Construction != null)
{
foreach (Construction construction_Temp in constructions)
{
if (construction_Temp.Name == face.Properties.Energy.Construction)
{
construction = construction_Temp;
break;
}
}
}
AnyOf <Ground, Outdoors, Adiabatic, Surface> boundaryCondition = face.BoundaryCondition;
if (boundaryCondition.Obj is Ground)
{
switch (panelGroup)
{
case PanelGroup.Floor:
panelType = PanelType.SlabOnGrade;
break;
case PanelGroup.Other:
panelType = PanelType.Air;
break;
case PanelGroup.Roof:
panelType = PanelType.UndergroundCeiling;
break;
case PanelGroup.Wall:
panelType = PanelType.UndergroundWall;
break;
}
}
else if (boundaryCondition.Obj is Adiabatic)
{
if (panelGroup == PanelGroup.Roof)
{
panelType = PanelType.Roof;
}
}
else if (boundaryCondition.Obj is Outdoors)
{
switch (panelGroup)
{
case PanelGroup.Floor:
panelType = PanelType.FloorExposed;
break;
case PanelGroup.Other:
panelType = PanelType.Shade;
break;
case PanelGroup.Roof:
panelType = PanelType.Roof;
break;
case PanelGroup.Wall:
panelType = PanelType.WallExternal;
break;
}
}
else if (boundaryCondition.Obj is Surface)
{
Surface surface = (Surface)boundaryCondition.Obj;
switch (panelGroup)
{
case PanelGroup.Floor:
panelType = PanelType.FloorInternal;
break;
case PanelGroup.Wall:
panelType = PanelType.WallInternal;
break;
}
}
if (construction == null)
{
AnyOf <OpaqueConstructionAbridged, WindowConstructionAbridged, ShadeConstruction, AirBoundaryConstructionAbridged> construction_Honeybee = Query.DefaultConstruction(panelType);
if (construction_Honeybee != null)
{
construction = construction_Honeybee.ToSAM_Construction();
}
}
if (construction == null)
{
construction = new Construction(face.Identifier);
}
Panel panel = Create.Panel(construction, panelType, face3D);
if (face.Apertures != null)
{
foreach (HoneybeeSchema.Aperture aperture_HoneybeeSchema in face.Apertures)
{
Aperture aperture = aperture_HoneybeeSchema?.ToSAM(panelType.Internal(), apertureConstructions);
if (aperture != null)
{
panel.AddAperture(aperture);
}
}
}
if (face.Doors != null)
{
foreach (HoneybeeSchema.Door door in face.Doors)
{
Aperture aperture = door?.ToSAM(panelType.Internal(), apertureConstructions);
if (aperture != null)
{
panel.AddAperture(aperture);
}
}
}
return(panel);
}
/// <summary>
/// Converts Face3D to Wall
/// </summary>
/// <param name="face3D">SAM Geometry Face3D</param>
/// <param name="document">Revit Document</param>
/// <param name="wallType">Revit WallType. Default WallType will be used if null</param>
/// <param name="level">Revit Level. Low Level for Face3D will be used if null</param>
/// <returns>Revit Wall</returns>
public static Autodesk.Revit.DB.Wall ToRevit_Wall(this Geometry.Spatial.Face3D face3D, Document document, Autodesk.Revit.DB.WallType wallType = null, Level level = null)
{
if (face3D == null || document == null)
{
return(null);
}
if (face3D.GetArea() < Core.Tolerance.MacroDistance)
{
return(null);
}
Geometry.Spatial.Vector3D normal = face3D.GetPlane().Normal;
if (normal == null)
{
return(null);
}
if (wallType == null)
{
ElementId elementId = document.Settings.Categories.get_Item(BuiltInCategory.OST_Walls).Id;
if (elementId != null && elementId != ElementId.InvalidElementId)
{
elementId = document.GetDefaultFamilyTypeId(elementId);
if (elementId != null && elementId != ElementId.InvalidElementId)
{
wallType = document.GetElement(elementId) as Autodesk.Revit.DB.WallType;
}
}
}
if (wallType == null)
{
return(null);
}
if (level == null)
{
double elevation = Geometry.Revit.Convert.ToRevit(face3D.GetBoundingBox().Min).Z;
level = Core.Revit.Query.LowLevel(document, elevation);
}
if (level == null)
{
return(null);
}
List <CurveLoop> curveLoops = Geometry.Revit.Convert.ToRevit(face3D);
curveLoops?.RemoveAll(x => x == null);
if (curveLoops == null || curveLoops.Count == 0)
{
return(null);
}
XYZ xyz_Normal = Geometry.Revit.Convert.ToRevit(normal, false);
if (curveLoops.Count == 1)
{
return(Autodesk.Revit.DB.Wall.Create(document, curveLoops[0].ToList(), wallType.Id, level.Id, false, xyz_Normal));
}
//The Wall.Create method requires the curveLoops to be in either all counter-clockwise direction or all clockwise direction.
for (int i = 0; i < curveLoops.Count; i++)
{
if (curveLoops[i].IsCounterclockwise(xyz_Normal))
{
curveLoops[i].Flip();
}
}
List <Curve> curves = new List <Curve>();
//According to https://forums.autodesk.com/t5/revit-api-forum/wall-create-by-profile/td-p/8961085
//CurveLoops have to be organised in correct order. Hypothesis :
//If the curveLoop contains 1 (or more) vertical Line(s), the vertical line should be the first to add to the List.
foreach (CurveLoop curveLoop in curveLoops)
{
List <Curve> curves_Temp = curveLoop?.ToList();
if (curveLoop == null)
{
continue;
}
List <Curve> curves_Postponed = new List <Curve>();
int startindex = 0;
while (startindex < curves_Temp.Count)
{
Curve curve = curves_Temp[startindex];
if (!(curve is Line))
{
curves_Postponed.Add(curve);
startindex++;
continue;
}
XYZ dir = curve.GetEndPoint(1).Subtract(curve.GetEndPoint(0)).Normalize();
if (!dir.IsAlmostEqualTo(XYZ.BasisZ) && !dir.IsAlmostEqualTo(XYZ.BasisZ.Negate()))
{
curves_Postponed.Add(curve);
startindex++;
}
else
{
break;
}
}
for (int i = startindex; i < curves_Temp.Count; i++)
{
Curve curve = curves_Temp[i];
curves.Add(curve);
}
if (curves_Postponed.Count > 0)
{
curves.AddRange(curves_Postponed);
}
}
if (curves == null || curves.Count == 0)
{
return(null);
}
return(Autodesk.Revit.DB.Wall.Create(document, curves, wallType.Id, level.Id, false, xyz_Normal));
}
public static List <Panel> SimilarPanels(this Geometry.Spatial.Face3D face3D, Dictionary <Panel, Geometry.Spatial.Face3D> panelsDictionary, double distanceTolerance = Tolerance.MacroDistance, double coplanarTolerance = Tolerance.MacroDistance)
{
if (face3D == null || panelsDictionary == null)
{
return(null);
}
Geometry.Spatial.Plane plane = face3D.GetPlane();
Geometry.Planar.IClosed2D closed2D_1 = Geometry.Spatial.Query.Convert(plane, face3D.GetExternalEdge3D());
Geometry.Planar.Point2D point2D_Internal = closed2D_1.GetInternalPoint2D();
double area = face3D.GetArea();
List <Tuple <Panel, double> > tuples = new List <Tuple <Panel, double> >();
foreach (KeyValuePair <Panel, Geometry.Spatial.Face3D> keyValuePair in panelsDictionary)
{
if (keyValuePair.Value == null)
{
continue;
}
Geometry.Spatial.Face3D face3D_Temp = keyValuePair.Value;
Geometry.Spatial.Plane plane_Temp = face3D_Temp.GetPlane();
if (!plane.Coplanar(plane_Temp, coplanarTolerance))
{
continue;
}
Geometry.Spatial.Point3D point3D_Origin = plane_Temp.Origin;
Geometry.Spatial.Point3D point3D_Project = Geometry.Spatial.Query.Project(plane, point3D_Origin);
if (point3D_Origin.Distance(point3D_Project) > distanceTolerance)
{
continue;
}
Geometry.Planar.IClosed2D closed2D_2 = Geometry.Spatial.Query.Convert(plane, face3D_Temp.GetExternalEdge3D());
if (closed2D_2.Inside(point2D_Internal))
{
tuples.Add(new Tuple <Panel, double>(keyValuePair.Key, Math.Abs(keyValuePair.Value.GetArea() - area)));
}
}
if (tuples == null || tuples.Count == 0)
{
return(null);
}
if (tuples.Count == 1)
{
return new List <Panel>()
{
tuples.First().Item1
}
}
;
tuples.Sort((x, y) => x.Item2.CompareTo(y.Item2));
double areatolerance = distanceTolerance * 10;
List <Panel> result = tuples.FindAll(x => x.Item2 < areatolerance).ConvertAll(x => x.Item1);
if (result != null && result.Count > 0)
{
return(result);
}
return(new List <Panel>()
{
tuples.First().Item1
});
}
}
public static List <TBD.SurfaceShade> UpdateSurfaceShades(this TBD.Building building, List <TBD.DaysShade> daysShades, TBD.zoneSurface zoneSurface, AnalyticalModel analyticalModel, Geometry.SolarCalculator.SolarFaceSimulationResult solarFaceSimulationResult, double tolerance = 0.01)
{
if (daysShades == null || analyticalModel == null || solarFaceSimulationResult == null || zoneSurface == null)
{
return(null);
}
Panel panel = analyticalModel.GetRelatedObjects <Panel>(solarFaceSimulationResult)?.FirstOrDefault();
if (panel == null)
{
return(null);
}
Geometry.Spatial.Face3D face3D = panel.Face3D;
if (face3D == null)
{
return(null);
}
double area = face3D.GetArea();
if (double.IsNaN(area) || area == 0)
{
return(null);
}
List <TBD.SurfaceShade> result = new List <TBD.SurfaceShade>();
List <DateTime> dateTimes = solarFaceSimulationResult.DateTimes;
if (dateTimes == null || dateTimes.Count == 0)
{
return(result);
}
foreach (DateTime dateTime in dateTimes)
{
double sunExposureArea = solarFaceSimulationResult.GetSunExposureArea(dateTime);
if (double.IsNaN(sunExposureArea) || sunExposureArea == 0)
{
continue;
}
int dayIndex = dateTime.DayOfYear;
TBD.DaysShade daysShade = daysShades.Find(x => x.day == dayIndex);
if (daysShade == null)
{
daysShade = building.AddDaysShade();
daysShade.day = dayIndex;
daysShades.Add(daysShade);
}
float proportion = System.Convert.ToSingle(Core.Query.Round(sunExposureArea / area, tolerance));
if (proportion <= tolerance)
{
proportion = 0;
}
TBD.SurfaceShade surfaceShade = daysShade.AddSurfaceShade(System.Convert.ToInt16(dateTime.Hour));
surfaceShade.proportion = proportion;
surfaceShade.surface = zoneSurface;
result.Add(surfaceShade);
}
return(result);
}
