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)));
}
