public static bool IsNearGrid(this IElement1D element1D, Grid grid, double maxDistance) { ICurve curve = element1D.IGeometry().IProject(Plane.XY); ICurve gridCurve = grid.Curve.IProject(Plane.XY); return(curve.Distance(gridCurve) <= maxDistance); }
public static bool IsNearLevel(this IElement1D element1D, Level level, double maxDistance) { ICurve curve = element1D.IGeometry(); BoundingBox bBox = curve.IBounds(); return(bBox.Min.Z - maxDistance <= level.Elevation && level.Elevation <= bBox.Max.Z + maxDistance); }
public static Output <List <IElement1D>, List <IElement2D> > EdgeAdjacencies(this IElement1D edge, IEnumerable <IElement2D> elements, double tolerance = Tolerance.Distance) { if (edge == null || elements == null) { Reflection.Compute.RecordWarning("Can not get adjacencies of a null element."); return(null); } List <IElement1D> adjEdges = new List <IElement1D>(); List <IElement2D> adjElems = new List <IElement2D>(); foreach (IElement2D elem in elements) { List <IElement1D> edges = elem.IOutlineElements1D(); foreach (IElement1D refEdge in edges) { if (Query.IIsAdjacent(refEdge, edge)) { adjEdges.Add(refEdge); adjElems.Add(elem); } } } // Return the adjacencies return(new Output <List <IElement1D>, List <IElement2D> > { Item1 = adjEdges, Item2 = adjElems, }); }
public static List <Point> ElementVertices(this IElement1D element1D) { ICurve curve = element1D.IGeometry(); List <Point> vertices = new List <Point>(); List <ICurve> subParts = curve.ISubParts().ToList(); if (subParts.Count == 0 || subParts.All(x => x is Circle)) { return(new List <Point>()); } vertices.Add(curve.IStartPoint()); foreach (ICurve c in subParts) { List <Point> discPoints = c.IDiscontinuityPoints(); if (discPoints.Count != 0) { vertices.AddRange(discPoints.Skip(1)); } } if (curve.IIsClosed()) { vertices.RemoveAt(vertices.Count - 1); } return(vertices); }
public static IElement1D ITransform(this IElement1D element1D, TransformMatrix transform, double tolerance = Tolerance.Distance) { object result; if (!Reflection.Compute.TryRunExtensionMethod(element1D, "Transform", new object[] { transform, tolerance }, out result)) result = element1D.Transform(transform, tolerance); return result as IElement1D; }
public static string IPrimaryPropertyName(this IElement1D elem) { if (elem == null) { return(null); } return(PrimaryPropertyName(elem as dynamic)); }
/***************************************************/ private static IElement1D Transform(this IElement1D element1D, TransformMatrix transform, double tolerance) { if (!transform.IsRigidTransformation(tolerance)) { BH.Engine.Reflection.Compute.RecordError("Transformation failed: only rigid body transformations are currently supported."); return null; } return element1D.ISetGeometry(Geometry.Modify.ITransform(element1D.IGeometry(), transform)); }
public static bool IIsAdjacent(this IElement1D elem1, IElement1D elem2, double tolerance = Tolerance.Distance) { if (elem1 == null || elem2 == null) { BH.Engine.Reflection.Compute.RecordError("Cannot query the adjacency of two IElement1Ds if either is null."); return(false); } return(IsAdjacent(elem1 as dynamic, elem2 as dynamic)); }
/***************************************************/ private static bool IsAdjacent(this IElement1D elem1, IElement1D elem2, double tolerance = Tolerance.Distance) { if (elem1 == null || elem2 == null) { BH.Engine.Reflection.Compute.RecordError("Cannot query the adjacency of two IElement1Ds if either is null."); return(false); } Reflection.Compute.RecordWarning($"IsAdjacent is not implemented for a combination of {elem1.GetType().Name} and {elem2.GetType().Name}."); return(false); }
public static List <IElement1D> AdjacentElements(this IElement1D element, IEnumerable <IElement1D> referenceElements) { if (element == null || referenceElements == null) { Reflection.Compute.RecordWarning("Can not get adjacencies of a null element."); return(null); } return(referenceElements.Where(x => x.IIsAdjacent(element)).ToList()); }
public static BH.oM.Geometry.Vector DominantVector(this IElement2D element2D, bool orthogonalPriority = true, double orthogonalLengthFactor = 0.5, double angleTolerance = BH.oM.Geometry.Tolerance.Angle) { if (element2D == null || orthogonalPriority == null || orthogonalLengthFactor == null || angleTolerance == null) { BH.Engine.Reflection.Compute.RecordError("One or more of the inputs is empty or null."); return(null); } IElement1D outline = BH.Engine.Geometry.Create.PolyCurve(element2D.IOutlineElements1D().Select(x => x.IGeometry())); return(DominantVector(outline, orthogonalPriority, orthogonalLengthFactor, angleTolerance)); }
/******************************************/ /**** IElement1D ****/ /******************************************/ public static List <Point> ElementVertices(this IElement1D element1D) { ICurve curve = element1D.IGeometry(); List <Point> vertices = curve.IDiscontinuityPoints(); if (curve.IIsClosed()) { vertices.RemoveAt(vertices.Count - 1); } return(vertices); }
public static BH.oM.Geometry.Vector DominantVector(this IElement1D element1D, bool orthogonalPriority = true, double orthogonalLengthFactor = 0.5, double angleTolerance = BH.oM.Geometry.Tolerance.Angle) { if (element1D == null || orthogonalPriority == null || orthogonalLengthFactor == null || angleTolerance == null) { BH.Engine.Reflection.Compute.RecordError("One or more of the inputs is empty or null."); return(null); } List <ICurve> curves = element1D.IGeometry().ISubParts().ToList(); if (!curves.Any(x => x.IIsLinear())) { BH.Engine.Reflection.Compute.RecordWarning("Non-linear curves are using an approximate vector between its start and end."); } List <Vector> vectors = curves.Select(x => (x.IStartPoint() - x.IEndPoint())).ToList(); //group vectors by direction whilst comparing angle for tolerance List <List <Vector> > groupByNormal = GroupSimilarVectorsWithTolerance(vectors, angleTolerance); groupByNormal = groupByNormal.OrderByDescending(x => x.Sum(y => y.Length())).ToList(); List <Vector> largestGlobal = groupByNormal[0]; Vector dominantVector = largestGlobal[0].Normalise(); if (!orthogonalPriority) { return(dominantVector); } List <Vector> largestOrthogonal = groupByNormal.FirstOrDefault(x => (x.First().IsOrthogonal(angleTolerance))); if (largestOrthogonal != null) { if (largestGlobal.Sum(x => x.Length()) * orthogonalLengthFactor > largestOrthogonal.Sum(x => x.Length())) { BH.Engine.Reflection.Compute.RecordWarning("Orthogonal vector was found but didn't pass the length tolerance in relation to the actual non-orthogonal dominant vector. The actual dominant vector is the output."); } else { dominantVector = largestOrthogonal[0].Normalise(); } } return(dominantVector); }
/***************************************************/ public static IBHoMObject FromRevit(this MultiSegmentGrid grid, Discipline discipline, Transform transform = null, RevitSettings settings = null, Dictionary <string, List <IBHoMObject> > refObjects = null) { IElement1D result = null; switch (discipline) { default: result = grid.GridFromRevit(settings, refObjects); break; } if (result != null && transform?.IsIdentity == false) { TransformMatrix bHoMTransform = transform.FromRevit(); result = result.ITransform(bHoMTransform); } return(result as IBHoMObject); }
/***************************************************/ public static BoundingBox ElementBoundingBox(IElement1D element1d, double localYDimension, double localZDimension) { Line line = element1d as Line; if (line != null) { return(ElementBoundingBox(line, localYDimension, localZDimension)); } ICurve crv = element1d as ICurve; if (element1d != null) { line = BH.Engine.Geometry.Create.Line(crv.IStartPoint(), crv.IEndPoint()); return(ElementBoundingBox(line, localYDimension, localZDimension)); } BH.Engine.Reflection.Compute.RecordError($"This method currently supports only Elements that are of type {nameof(Line)}."); return(null); }
public static IBHoMObject FromRevit(this Autodesk.Revit.DB.Electrical.Wire wire, Discipline discipline, Transform transform = null, RevitSettings settings = null, Dictionary <string, List <IBHoMObject> > refObjects = null) { IElement1D result = null; switch (discipline) { case Discipline.Architecture: case Discipline.Physical: case Discipline.Environmental: result = wire.WireFromRevit(settings, refObjects); break; } if (result != null && transform?.IsIdentity == false) { TransformMatrix bHoMTransform = transform.FromRevit(); result = result.ITransform(bHoMTransform); } return(result as IBHoMObject); }
public static List <IElement2D> AdjacentElements(this IElement1D element, IEnumerable <IElement2D> referenceElements) { List <IElement2D> adjacentElements = new List <IElement2D>(); if (element == null || referenceElements == null) { Reflection.Compute.RecordWarning("Can not get adjacencies of a null element."); return(null); } PolyCurve outline = element.ElementCurves().IJoin()[0]; foreach (IElement2D refElem in referenceElements) { PolyCurve refOutline = refElem.OutlineCurve(); if (refOutline.IIsAdjacent(outline)) { adjacentElements.Add(refElem); } } return(adjacentElements); }
public static string AdjacencyID(this List <IElement1D> edges, List <IElement2D> elems) { string separator = "_"; List <string> adjIDs = new List <string>(); if (edges.Count != elems.Count) { Reflection.Compute.RecordWarning("Edge and element list lengths do not match. Each edge should have a corresponding element, please check your inputs."); return(null); } else { for (int i = 0; i < edges.Count; i++) { IElement1D edge = edges[i]; IElement2D elem = elems[i]; string adjID = "Elem:" + elem.IPrimaryPropertyName() + " " + "Edge:" + edge.IPrimaryPropertyName(); adjIDs.Add(adjID); } } adjIDs.Sort(); return(string.Join(separator, adjIDs)); }
public static List <ICurve> ElementCurves(this IElement1D element1D, bool recursive = true) { return(new List <ICurve> { element1D.IGeometry() }); }
public static bool IsSelfIntersecting(this IElement1D element1D, double tolerance = Tolerance.Distance) { return(Geometry.Query.IIsSelfIntersecting(element1D.IGeometry(), tolerance)); }
public static bool IHasMergeablePropertiesWith(this IElement1D element, IElement1D other) { return(HasMergeablePropertiesWithIElement(element, other)); }
/******************************************/ /**** IElement1D ****/ /******************************************/ public static IElement1D ISetGeometry(this IElement1D element1D, ICurve curve) { return(Reflection.Compute.RunExtensionMethod(element1D, "SetGeometry", new object[] { curve }) as IElement1D); }
public static ICurve IGeometry(this IElement1D element1D) { return(Reflection.Compute.RunExtensionMethod(element1D, "Geometry") as ICurve); }
public static List <Point> ControlPoints(this IElement1D element1D) { return(Geometry.Query.IControlPoints(element1D.IGeometry())); }
/***************************************************/ /**** Private Fallback Methods ****/ /***************************************************/ private static string PrimaryPropertyName(this IElement1D elem) { return(""); }
public static BoundingBox Bounds(this IElement1D element1D) { return(Geometry.Query.IBounds(element1D.IGeometry())); }
public static Point Centroid(this IElement1D element1D) { //TODO: find a proper centre of weight of a curve (not an average of control points) throw new NotImplementedException(); }
public static IElement1D Translate(this IElement1D element1D, Vector transform) { return(element1D.ISetGeometry(Geometry.Modify.ITranslate(element1D.IGeometry(), transform))); }
public static IElement0D INewElement0D(this IElement1D element1D, Point point) { return(point); }
/***************************************************/ public static IElement1D Translate(this IElement1D element1D, Vector transform) //todo: move this to analytical along with other IElement methods { return(element1D.ISetGeometry(Geometry.Modify.ITranslate(element1D.IGeometry(), transform))); }