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);
}
/// <summary>
/// This is the method that actually does the work.
/// </summary>
/// <param name="dataAccess">
/// The DA object is used to retrieve from inputs and store in outputs.
/// </param>
protected override void SolveInstance(IGH_DataAccess dataAccess)
{
bool run = false;
if (!dataAccess.GetData(2, ref run) || !run)
{
return;
}
bool merge = true;
if (!dataAccess.GetData(1, ref merge))
{
return;
}
GH_ObjectWrapper objectWrapper = null;
if (!dataAccess.GetData(0, ref objectWrapper) || objectWrapper.Value == null)
{
AddRuntimeMessage(GH_RuntimeMessageLevel.Error, "Invalid data");
return;
}
dynamic obj = objectWrapper.Value;
ElementId aId = obj.Id as ElementId;
string message = null;
Document document = obj.Document as Document;
Autodesk.Revit.DB.Mechanical.Space space = document.GetElement(aId) as Autodesk.Revit.DB.Mechanical.Space;
if (space == null)
{
message = "Invalid Element";
AddRuntimeMessage(GH_RuntimeMessageLevel.Error, message);
return;
}
if (space.Location == null)
{
message = string.Format("Cannot generate Panels. Space {0} [ElementId: {1}] not enclosed", space.Name, space.Id.IntegerValue);
AddRuntimeMessage(GH_RuntimeMessageLevel.Warning, message);
return;
}
if (space.Volume < Core.Tolerance.MacroDistance)
{
message = string.Format("Space cannot be converted because it has no volume. Space {0} [ElementId: {1}] not enclosed", space.Name, space.Id.IntegerValue);
AddRuntimeMessage(GH_RuntimeMessageLevel.Warning, message);
return;
}
ConvertSettings convertSettings = new ConvertSettings(true, true, true);
List <Panel> panels = Analytical.Revit.Create.Panels(space, convertSettings);
if (panels == null || panels.Count == 0)
{
message = "Panels ould not be generated";
AddRuntimeMessage(GH_RuntimeMessageLevel.Error, message);
return;
}
panels.RemoveAll(x => x == null);
List <Panel> panels_Temp = new List <Panel>();
foreach (Panel panel in panels)
{
PanelGroup panelGroup = Analytical.Query.PanelGroup(panel.PanelType);
if (panelGroup != PanelGroup.Floor && panelGroup != PanelGroup.Roof)
{
continue;
}
ElementId elementId = panel.ElementId();
if (elementId == null || elementId == ElementId.InvalidElementId)
{
panels_Temp.Add(panel);
continue;
}
HostObject hostObject = document.GetElement(elementId) as HostObject;
if (hostObject == null)
{
panels_Temp.Add(panel);
continue;
}
Geometry.Spatial.Plane plane = panel.PlanarBoundary3D.Plane;
List <Geometry.Spatial.Face3D> face3Ds = Geometry.Revit.Query.Profiles(hostObject);
if (face3Ds == null || face3Ds.Count == 0)
{
panels_Temp.Add(panel);
continue;
}
Geometry.Spatial.Plane plane_Face3D = face3Ds.Find(x => plane.Coplanar(x.GetPlane()))?.GetPlane();
if (plane_Face3D == null)
{
panels_Temp.Add(panel);
continue;
}
Geometry.Spatial.Point3D point3D_Projected = plane_Face3D.Project(plane.Origin);
panel.Move(new Geometry.Spatial.Vector3D(plane.Origin, point3D_Projected));
panels_Temp.Add(panel);
}
List <Panel> redundantPanels = new List <Panel>();
if (merge)
{
panels_Temp = Analytical.Query.MergeCoplanarPanels(panels_Temp, Core.Tolerance.MacroDistance, ref redundantPanels, true, Core.Tolerance.MacroDistance);
}
dataAccess.SetDataList(0, panels_Temp.FindAll(x => Analytical.Query.PanelGroup(x.PanelType) == PanelGroup.Floor));
dataAccess.SetDataList(1, panels_Temp.FindAll(x => Analytical.Query.PanelGroup(x.PanelType) == PanelGroup.Roof));
dataAccess.SetDataList(2, redundantPanels);
}
public static FamilyInstance ToRevit(this Aperture aperture, Document document, HostObject hostObject, Core.Revit.ConvertSettings convertSettings)
{
if (aperture == null || document == null)
{
return(null);
}
FamilyInstance result = convertSettings?.GetObject <FamilyInstance>(aperture.Guid);
if (result != null)
{
return(result);
}
ApertureConstruction apertureConstruction = aperture.ApertureConstruction;
if (apertureConstruction == null)
{
return(null);
}
FamilySymbol familySymbol = apertureConstruction.ToRevit(document, convertSettings);
if (familySymbol == null)
{
familySymbol = Analytical.Query.DefaultApertureConstruction(hostObject.PanelType(), apertureConstruction.ApertureType).ToRevit(document, convertSettings); //Default Aperture Construction
}
if (familySymbol == null)
{
return(null);
}
Point3D point3D_Location = aperture.PlanarBoundary3D?.Plane?.Origin;
if (point3D_Location == null)
{
return(null);
}
Level level = Geometry.Revit.Query.LowLevel(document, point3D_Location.Z);
if (level == null)
{
return(null);
}
XYZ referenceDirection = new XYZ(0, 0, 0);
if (hostObject is RoofBase)
{
Face3D face3D = aperture.GetFace3D();
Geometry.Spatial.Plane plane = face3D.GetPlane();
bool coplanar = plane.Coplanar(Geometry.Spatial.Plane.WorldXY);
//if(coplanar)
//{
// referenceDirection = new XYZ(0, 0, 1);
//}
result = document.Create.NewFamilyInstance(point3D_Location.ToRevit(), familySymbol, referenceDirection, hostObject, Autodesk.Revit.DB.Structure.StructuralType.NonStructural);
if (result == null)
{
return(null);
}
//List<Geometry.Planar.Point2D> point2Ds = new List<Geometry.Planar.Point2D>();
//IClosedPlanar3D closedPlanar3D = face3D.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()));
// }
//}
//Geometry.Planar.Rectangle2D rectangle2D = Geometry.Planar.Create.Rectangle2D(point2Ds);
Geometry.Planar.Rectangle2D rectangle2D = Analytical.Create.Rectangle2D(aperture.PlanarBoundary3D);
if (rectangle2D == null)
{
return(null);
}
document.Regenerate();
result = document.GetElement(result.Id) as FamilyInstance;
Vector3D handOrientation_FamilyInstance = result.HandOrientation.ToSAM_Vector3D(false);
Vector3D facingOrientation_FamilyInstance = result.FacingOrientation.ToSAM_Vector3D(false);
double factor = 0;
Geometry.Planar.Vector2D direction = rectangle2D.WidthDirection;
if (!coplanar && Core.Query.Round(direction.Y) < 0)
{
factor = System.Math.PI / 2;
}
Vector3D handOrienation_Aperture = plane.Convert(direction);
Geometry.Spatial.Plane plane_FamilyInstance = new Geometry.Spatial.Plane(point3D_Location, handOrientation_FamilyInstance, facingOrientation_FamilyInstance);
handOrienation_Aperture = plane_FamilyInstance.Project(handOrienation_Aperture);
double angle = Geometry.Spatial.Query.SignedAngle(handOrientation_FamilyInstance, handOrienation_Aperture, plane.Normal);
result.Location.Rotate(Line.CreateUnbound(point3D_Location.ToRevit(), plane.Normal.ToRevit(false)), angle + factor);
//document.Regenerate();
//BoundingBox3D boundingBox3D_familyInstance = familyInstance.BoundingBox3D();
//BoundingBox3D boundingBox3D_Aperture = aperture.GetBoundingBox();
//if(boundingBox3D_familyInstance.Min.Distance(boundingBox3D_Aperture.Min) > SAM.Core.Tolerance.MacroDistance)
// familyInstance.Location.Rotate(Line.CreateUnbound(point3D_Location.ToRevit(), plane.Normal.ToRevit(false)), System.Math.PI / 2);
//Geometry.Planar.Rectangle2D rectangle2D = Geometry.Planar.Create.Rectangle2D(point2Ds);
//Geometry.Planar.Vector2D direction = null;
//if (rectangle2D.Height > rectangle2D.Width)
// direction = rectangle2D.HeightDirection;
//else
// direction = rectangle2D.WidthDirection;
//double angle = plane.Convert(direction).ToRevit(false).AngleTo(new XYZ(0, 1, 0));
//angle = System.Math.PI - angle;
////if (angle > System.Math.PI)
//// angle = -(angle - System.Math.PI);
//if (direction.X < 0)
// angle = -angle;
//familyInstance.Location.Rotate(Line.CreateUnbound(point3D_Location.ToRevit(), plane.Normal.ToRevit(false)), angle);
}
else
{
result = document.Create.NewFamilyInstance(point3D_Location.ToRevit(), familySymbol, hostObject, level, Autodesk.Revit.DB.Structure.StructuralType.NonStructural);
}
if (result == null)
{
return(null);
}
if (result.CanFlipHand)
{
document.Regenerate(); //This is needed to get flip correctly pushed to revit
Vector3D axisX = result.HandOrientation.ToSAM_Vector3D(false);
if (!axisX.SameHalf(aperture.Plane.AxisX))
{
result.flipHand();
}
}
if (result.CanFlipFacing)
{
document.Regenerate(); //This is needed to get flip correctly pushed to revit
Vector3D normal = result.FacingOrientation.ToSAM_Vector3D(false);
if (!normal.SameHalf(aperture.Plane.Normal))
{
result.flipFacing();
}
}
if (convertSettings.ConvertParameters)
{
Core.Revit.Modify.SetValues(result, aperture, new BuiltInParameter[] { BuiltInParameter.INSTANCE_SILL_HEIGHT_PARAM, BuiltInParameter.INSTANCE_HEAD_HEIGHT_PARAM, BuiltInParameter.FAMILY_LEVEL_PARAM, BuiltInParameter.SCHEDULE_LEVEL_PARAM });
Core.Revit.Modify.SetValues(result, aperture, ActiveSetting.Setting);
bool simplified = false;
//Check if geometry is simplified
if (!Geometry.Planar.Query.Rectangular(aperture.PlanarBoundary3D?.ExternalEdge2DLoop?.GetClosed2D(), Core.Tolerance.MacroDistance))
{
simplified = true;
}
if (!simplified && result.Host is Autodesk.Revit.DB.Wall)
{
Face3D face3D = aperture.GetFace3D();
Geometry.Spatial.Plane plane = face3D.GetPlane();
Geometry.Planar.Rectangle2D rectangle2D = Analytical.Create.Rectangle2D(aperture.PlanarBoundary3D);
if (rectangle2D != null)
{
Vector3D widthDirection = plane.Convert(rectangle2D.WidthDirection);
Vector3D heightDirection = plane.Convert(rectangle2D.HeightDirection);
//TODO: Implement code for Tilted Walls
Vector3D vector3D_Z = Vector3D.WorldZ;
if (!widthDirection.AlmostSimilar(vector3D_Z) && !heightDirection.AlmostSimilar(vector3D_Z))
{
simplified = true;
}
}
}
Core.Revit.Modify.SetSimplified(result, simplified);
Core.Revit.Modify.SetJson(result, aperture.ToJObject()?.ToString());
}
convertSettings?.Add(aperture.Guid, result);
return(result);
}
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
});
}
}