/// <summary> /// Form a Refernece plane from two end points in the Active view. The cut vector is the Z Axis. /// </summary> /// <param name="start">The location where the bubble will be located</param> /// <param name="end">The other end</param> /// <returns></returns> public static ReferencePlane ByStartPointEndPoint( Point start, Point end ) { if (start == null) { throw new ArgumentNullException("start"); } if (end == null) { throw new ArgumentNullException("end"); } return new ReferencePlane( start.ToXyz(), end.ToXyz(), (end.ToXyz() - start.ToXyz()).GetPerpendicular(), Document.ActiveView); }
public void NurbsCurve() { // create spline var pts = new Autodesk.DesignScript.Geometry.Point[] { Autodesk.DesignScript.Geometry.Point.ByCoordinates(0,0,0), Autodesk.DesignScript.Geometry.Point.ByCoordinates(1,0,0), Autodesk.DesignScript.Geometry.Point.ByCoordinates(3,0,0), Autodesk.DesignScript.Geometry.Point.ByCoordinates(10,0,0) }; var spline = Autodesk.DesignScript.Geometry.NurbsCurve.ByControlPoints(pts, 3); Assert.NotNull(spline); Assert.AreEqual(3, spline.Degree); var eval0 = spline.PointAtParameter(0); var eval1 = spline.PointAtParameter(1); var expectedPoint0 = Point.ByCoordinates(0, 0, 0); var expectedPoint1 = Point.ByCoordinates(10, 0, 0); Assert.AreEqual(0, expectedPoint0.DistanceTo(eval0), 1e-6); Assert.AreEqual(0, expectedPoint1.DistanceTo(eval1), 1e-6); var closestPoint0 = spline.ClosestPointTo(expectedPoint0); Assert.AreEqual(0, expectedPoint0.DistanceTo(closestPoint0), 1e-6); }
public void ByPoints_PointArray_ProducesValidAdaptiveComponentAndLocations() { var pts = new Point[] { Point.ByCoordinates(0, 0, 0), Point.ByCoordinates(10, 0, 10), Point.ByCoordinates(20, 0, 0) }; var fs = FamilySymbol.ByName("3PointAC"); var ac = AdaptiveComponent.ByPoints(pts, fs); var locs = ac.Locations; var pairs = locs.Zip(pts, (point, point1) => new Tuple<Point, Point>(point, point1)); // compares after unit conversion foreach (var pair in pairs) pair.Item1.ShouldBeApproximately(pair.Item2); var unconvertedPairs = pts.Zip(GetInternalPoints((FamilyInstance) ac.InternalElement), (point, point1) => new Tuple<Point, XYZ>(point, point1)); foreach (var pair in unconvertedPairs) { pair.Item1.ShouldBeApproximately(pair.Item2 * UnitConverter.HostToDynamoFactor); } Assert.NotNull(ac); }
private InvWorkPoint(Point point, IObjectBinder binder) { this.point = point; this.binder = binder; if (binder.DocumentManager.ActiveAssemblyDoc != null) { this.binder.ContextManager.BindingContextManager = binder.DocumentManager.ActiveAssemblyDoc.ReferenceKeyManager; } else if (binder.DocumentManager.ActivePartDoc != null) { this.binder.ContextManager.BindingContextManager = binder.DocumentManager.ActivePartDoc.ReferenceKeyManager; } this.binder.ContextManager.BindingContextManager = binder.DocumentManager.ActiveAssemblyDoc.ReferenceKeyManager; Inventor.WorkPoint wp; if (this.binder.GetObjectFromTrace<Inventor.WorkPoint>(out wp)) { InternalWorkPoint = wp; AssemblyWorkPointDef wpDef = (AssemblyWorkPointDef)wp.Definition; wpDef.Point = point.ToPoint(); } else { wp = binder.DocumentManager.ActiveAssemblyDoc.ComponentDefinition.WorkPoints.AddFixed(point.ToPoint(), false); InternalWorkPoint = wp; this.binder.SetObjectForTrace<InvWorkPoint>(this.InternalWorkPoint); } }
/// <summary> /// Internal constructor for the AdaptiveComponent wrapper /// </summary> /// <param name="pts">Points to use as reference</param> /// <param name="fs">FamilySymbol to place</param> private AdaptiveComponent(Point[] pts, FamilySymbol fs) { // if the family instance is present in trace... var oldFam = ElementBinder.GetElementFromTrace<Autodesk.Revit.DB.FamilyInstance>(Document); // just mutate it... if (oldFam != null) { InternalSetFamilyInstance(oldFam); if (fs.InternalFamilySymbol.Id != oldFam.Symbol.Id) InternalSetFamilySymbol(fs); InternalSetPositions(pts.ToXyzs()); return; } // otherwise create a new family instance... TransactionManager.Instance.EnsureInTransaction(Document); var fam = AdaptiveComponentInstanceUtils.CreateAdaptiveComponentInstance(Element.Document, fs.InternalFamilySymbol); if (fam == null) throw new Exception("An adaptive component could not be found or created."); InternalSetFamilyInstance(fam); InternalSetPositions(pts.ToXyzs()); TransactionManager.Instance.TransactionTaskDone(); // remember this value ElementBinder.SetElementForTrace(this.InternalElement); }
protected Cone(Point startPoint, Point endPoint, double startRadius, double endRadius,bool persist) : base(ByStartPointEndPointRadiusCore(startPoint, endPoint, startRadius, endRadius),persist) { InitializeGuaranteedProperties(); StartPoint = startPoint; EndPoint = endPoint; StartRadius = startRadius; EndRadius = endRadius; }
/// <summary> /// Creates a Zone by a orientation, Origin and a building /// </summary> /// <param name="name"></param> /// <param name="orientation">The Orientation relative to the building</param> /// <param name="origin">The starting point of the zone</param> /// <param name="multiplier"></param> public Zone(string name, double orientation, Point origin, int multiplier = 1) { Name = name; Orientation = orientation; Origin = origin; Multiplier = multiplier; BuildingSurfaces = new List<BuildingSurface>(); SurfaceNumber = 1; }
/// <summary> /// Creates a Zone by a orientation, Origin and a building /// </summary> /// <param name="name"></param> /// <param name="orientation">The Orientation relative to the building</param> /// <param name="origin">The starting point of the zone</param> public Zone(string name, double orientation, Point origin) { Name = name; Orientation = orientation; Origin = origin; Multiplier = 1; Surfaces = new List<Surface>(); SurfaceNumber = 1; }
protected RevolvedSurface(Curve profile, Point axisOrigin, Vector axisDirection, double startAngle, double sweepAngle, bool persist) : base(ByProfileAxisOriginDirectionAngleCore(profile, axisOrigin, axisDirection, startAngle, sweepAngle), persist) { InitializeGuaranteedProperties(); Profile = profile; AxisOrigin = axisOrigin; AxisDirection = axisDirection; StartAngle = startAngle; SweepAngle = sweepAngle; }
public void ByPoints_NullFamilySymbol() { var pts = new Point[] { Point.ByCoordinates(0, 0, 0), Point.ByCoordinates(10, 0, 10), Point.ByCoordinates(20, 0, 0) }; Assert.Throws(typeof(ArgumentNullException), () => AdaptiveComponent.ByPoints(pts, null)); }
public void ByPoints_ShouldThrowExceptionWithNonMatchingNumberOfPoints() { var pts = new Point[] { Point.ByCoordinates(0, 0, 0), Point.ByCoordinates(10, 0, 10) }; var fs = FamilySymbol.ByName("3PointAC"); Assert.Throws(typeof (Exception), () => AdaptiveComponent.ByPoints(pts, fs)); }
public void ByPoints_ValidInput() { var pts = new Point[] { Point.ByCoordinates(0, 0, 0), Point.ByCoordinates(10, 0, 10), Point.ByCoordinates(20, 0, 0) }; var fs = FamilySymbol.ByName("3PointAC"); var ac = AdaptiveComponent.ByPoints(pts, fs); Assert.NotNull(ac); }
public static Dictionary<string,object> ByOriginDirection(Point origin, Vector direction, int maxBounces, Elements.Views.View3D view) { var startpt = origin.ToXyz(); var rayCount = 0; var bouncePts = new List<Point> {origin}; var bounceElements = new List<Elements.Element>(); for (int ctr = 1; ctr <= maxBounces; ctr++) { var referenceIntersector = new ReferenceIntersector((View3D)view.InternalElement); IList<ReferenceWithContext> references = referenceIntersector.Find(startpt, direction.ToXyz()); ReferenceWithContext rClosest = null; rClosest = FindClosestReference(references); if (rClosest == null) { break; } else { var reference = rClosest.GetReference(); var referenceElement = DocumentManager.Instance.CurrentDBDocument.GetElement(reference); var referenceObject = referenceElement.GetGeometryObjectFromReference(reference); bounceElements.Add(referenceElement.ToDSType(true)); var endpt = reference.GlobalPoint; if (startpt.IsAlmostEqualTo(endpt)) { break; } else { rayCount = rayCount + 1; var currFace = referenceObject as Face; var endptUV = reference.UVPoint; var FaceNormal = currFace.ComputeDerivatives(endptUV).BasisZ; // face normal where ray hits FaceNormal = rClosest.GetInstanceTransform().OfVector(FaceNormal); // transformation to get it in terms of document coordinates instead of the parent symbol var directionMirrored = direction.ToXyz() - 2 * direction.ToXyz().DotProduct(FaceNormal) * FaceNormal; //http://www.fvastro.org/presentations/ray_tracing.htm direction = directionMirrored.ToVector(); // get ready to shoot the next ray startpt = endpt; bouncePts.Add(endpt.ToPoint()); } } } return new Dictionary<string, object> { { "points", bouncePts }, { "elements", bounceElements } }; }
public void Line_Basic() { var line = Autodesk.DesignScript.Geometry.Line.ByStartPointEndPoint(Point.ByCoordinates(1, 2, 3), Point.ByCoordinates(2, 4, 6)); Console.WriteLine(line.PointAtParameter(0.5).ToXyz()); var revitCurve = line.ToRevitType(false); Assert.NotNull(revitCurve); Assert.IsAssignableFrom <Autodesk.Revit.DB.Line>(revitCurve); var revitArc = (Autodesk.Revit.DB.Line)revitCurve; line.StartPoint.ShouldBeApproximately(revitArc.GetEndPoint(0).ToPoint(false)); line.EndPoint.ShouldBeApproximately(revitArc.GetEndPoint(1).ToPoint(false)); }
public void ByEyePointAndTarget_ValidAbstractElement() { var eye = Point.ByCoordinates(100, 100, 100); var target = Point.ByCoordinates(0, 1, 2); var name = "treeView"; var famSym = FamilySymbol.ByName("Kousa Dogwood - 10'"); var pt = Point.ByCoordinates(0, 1, 2); var famInst = FamilyInstance.ByPoint(famSym, pt); object element = famInst; var view = AxonometricView.ByEyePointAndTarget(eye, target, element, name, false); Assert.NotNull(view); Assert.IsTrue(DocumentManager.Instance.ElementExistsInDocument( new ElementUUID(view.InternalElement.UniqueId))); }
/// <summary> /// Create an Advance Steel unbounded Rectangular Pattern at a Point /// </summary> /// <param name="connectionPoint"> Input Insertion point of Anchor Bolt Pattern </param> /// <param name="boltCS"> Input Anchor Bolt Coordinate System </param> /// <param name="noOfBoltsX"> Input No of Anchor Bolts in the X direction</param> /// <param name="noOfBoltsY"> Input No of Anchor Bolts in the Y direction</param> /// <param name="objectsToConnect"> Input Objects to be bolted </param> /// <param name="boltConnectionType"> Input Bolt Connection type - Shop Bolt Default</param> /// <param name="additionalAnchorBoltParameters"> Optional Input Anchor Bolt Build Properties </param> /// <returns name="rectangularAnchorPattern"> rectangularAnchorPattern</returns> public static RectangularAnchorPattern AtCentrePoint(Autodesk.DesignScript.Geometry.Point connectionPoint, Autodesk.DesignScript.Geometry.CoordinateSystem boltCS, [DefaultArgument("2;")] int noOfBoltsX, [DefaultArgument("2;")] int noOfBoltsY, IEnumerable <SteelDbObject> objectsToConnect, [DefaultArgument("2;")] int boltConnectionType, [DefaultArgument("null")] List <Property> additionalAnchorBoltParameters) { List <string> handlesList = Utils.GetSteelDbObjectsToConnect(objectsToConnect); var vx = Utils.ToAstVector3d(boltCS.XAxis, true); var vy = Utils.ToAstVector3d(boltCS.YAxis, true); additionalAnchorBoltParameters = PreSetValuesInListProps(additionalAnchorBoltParameters, noOfBoltsX, noOfBoltsY); return(new RectangularAnchorPattern(Utils.ToAstPoint(connectionPoint, true), handlesList, vx, vy, additionalAnchorBoltParameters, boltConnectionType)); }
public void Arc_Basic() { var circ = Autodesk.DesignScript.Geometry.Arc.ByCenterPointRadiusAngle(Point.ByCoordinates(1, 2, 3), 4, 0.4, 1.3, Vector.ByCoordinates(1, 2, 3)); var revitCurve = circ.ToRevitType(false); Assert.NotNull(revitCurve); Assert.IsAssignableFrom <Autodesk.Revit.DB.Arc>(revitCurve); var revitArc = (Autodesk.Revit.DB.Arc)revitCurve; circ.CenterPoint.ShouldBeApproximately(revitArc.Center.ToPoint(false)); circ.Radius.ShouldBeApproximately(revitArc.Radius); Math.Abs(circ.Normal.Dot(revitArc.Normal.ToVector())).ShouldBeApproximately(1); }
/// <summary> /// Form a Refernece plane from two end points in the Active view. The cut vector is the Z Axis. /// </summary> /// <param name="start">The location where the bubble will be located</param> /// <param name="end">The other end</param> /// <returns></returns> public static ReferencePlane ByStartPointEndPoint(Point start, Point end) { if (start == null) { throw new ArgumentNullException("start"); } if (end == null) { throw new ArgumentNullException("end"); } return(new ReferencePlane(start.ToXyz(), end.ToXyz(), (end.ToXyz() - start.ToXyz()).GetPerpendicular(), Document.ActiveView)); }
public void ByPointsOnCurve_ProducesValidAdaptiveComponentAndLocations() { // create spline var pts = new Autodesk.DesignScript.Geometry.Point[] { Point.ByCoordinates(0, 0, 0), Point.ByCoordinates(1, 0, 0), Point.ByCoordinates(3, 0, 0), Point.ByCoordinates(10, 0, 0), Point.ByCoordinates(12, 0, 0), }; var spline = NurbsCurve.ByControlPoints(pts, 3); Assert.NotNull(spline); // build model curve from spline var modCurve = ModelCurve.ByCurve(spline); Assert.NotNull(modCurve); // obtain the family from the document var ft = FamilyType.ByName("3PointAC"); // build the AC var parms = new double[] { 0, 0.5, 1 }; var ac = AdaptiveComponent.ByParametersOnCurveReference(parms, modCurve, ft); // with unit conversion foreach (var pt in ac.Locations) { spline.DistanceTo(pt).ShouldBeApproximately(0); } // without unit conversion var unconvertedPoints = GetInternalPoints((FamilyInstance)ac.InternalElement); foreach (var pt in unconvertedPoints) { spline.DistanceTo(pt.ToPoint()).ShouldBeApproximately(0); } Assert.NotNull(ac); }
/// <summary> /// Place an instance of a Model Group into the Autodesk Revit document, using a location and a group type. /// </summary> /// <param name="location">The point to place the group.</param> /// <param name="groupType">The type of group to place.</param> /// <returns>The new group instance.</returns> public static Group PlaceInstance(Autodesk.DesignScript.Geometry.Point location, Element groupType) { var internalType = groupType.InternalElement as Autodesk.Revit.DB.GroupType; if (internalType == null) { throw new InvalidOperationException(String.Format(Properties.Resources.InvalidGroupType, nameof(groupType))); } XYZ newLocation = location.ToRevitType(true); TransactionManager.Instance.EnsureInTransaction(Document); Group newGroup = Document.Create.PlaceGroup(newLocation, internalType).ToDSType(true) as Group; TransactionManager.Instance.TransactionTaskDone(); return(newGroup); }
internal List <Geo.Line> GetLinesAtParameter(tAgent[] agents, double parameter) { var lines = new List <Geo.Line>(); Geo.Point p = GetFurtherIntersection(_faceIndexA, agents); lines.Add(Geo.Line.ByStartPointDirectionLength(_edge.PointAtParameter(parameter), _lineDirectionA, 1)); if (!_isNaked) { p = GetFurtherIntersection(_faceIndexB, agents); lines.Add(Geo.Line.ByStartPointDirectionLength(_edge.PointAtParameter(parameter), _lineDirectionB, 1)); } // Dispose { p.Dispose(); } return(lines); }
/// <summary> /// Create an Advance Steel Circular Anchor Pattern By Center Point and Dynamo Coordinate System /// </summary> /// <param name="point"> Input radius center point</param> /// <param name="anchorCS"> Input Dynamo Coordinate System</param> /// <param name="objectsToConnect"> Input Objects to be bolted </param> /// <param name="anchorBoltConnectionType"> Input Bolt Connection type - Shop Bolt Default</param> /// <param name="additionalAnchorBoltParameters"> Optional Input Bolt Build Properties </param> /// <returns name="circularAnchorPattern"> anchor</returns> public static CircularAnchorPattern AtCentrePoint(DynGeometry.Point point, DynGeometry.CoordinateSystem anchorCS, IEnumerable <SteelDbObject> objectsToConnect, [DefaultArgument("2;")] int anchorBoltConnectionType, [DefaultArgument("null")] List <Property> additionalAnchorBoltParameters) { SteelGeometry.Point3d astPointRef = Utils.ToAstPoint(point, true); var vx = Utils.ToAstVector3d(anchorCS.XAxis, true); var vy = Utils.ToAstVector3d(anchorCS.YAxis, true); vx = vx.Normalize(); vy = vy.Normalize(); IEnumerable <string> handles = Utils.GetSteelDbObjectsToConnect(objectsToConnect); return(new CircularAnchorPattern(astPointRef, handles, vx, vy, additionalAnchorBoltParameters, anchorBoltConnectionType)); }
private InvWorkPoint(Point point, IObjectBinder binder) { _binder = binder; Inventor.WorkPoint wp; if (_binder.GetObjectFromTrace <Inventor.WorkPoint>(out wp)) { InternalWorkPoint = wp; AssemblyWorkPointDef wpDef = (AssemblyWorkPointDef)wp.Definition; wpDef.Point = point.ToPoint(); } else { wp = PersistenceManager.ActiveAssemblyDoc.ComponentDefinition.WorkPoints.AddFixed(point.ToPoint(), false); InternalWorkPoint = wp; _binder.SetObjectForTrace <WorkPoint>(this.InternalWorkPoint); } }
/// <summary> /// Callback method when gizmo is moved by user action. /// </summary> /// <param name="gizmo">Gizmo that moved.</param> /// <param name="offset">Offset by which the gizmo has moved.</param> /// <returns>New expected position of the Gizmo</returns> protected override Point OnGizmoMoved(IGizmo gizmo, Vector offset) { expectedPosition = origin.Add(offset); foreach (var item in indexedAxisNodePairs) { // When more than one input is connected to the same slider, this // method will decompose the axis corresponding to each input. var v = GetFirstAxisComponent(item.Value.Item1); var amount = Math.Round(offset.Dot(v), 3); if (Math.Abs(amount) > 0.001) { ModifyInputNode(item.Value.Item2, amount); } } return(expectedPosition); }
public void ByCoordinates_ProducesValidFamilyInstanceWithCorrectLocation() { var famSym = FamilyType.ByName("Box"); var famInst = FamilyInstance.ByCoordinates(famSym, 0, 1, 2); Assert.NotNull(famInst); var position = famInst.Location; position.ShouldBeApproximately(Point.ByCoordinates(0, 1, 2)); // no unit conversion var internalPos = InternalLocation(famInst.InternalElement as Autodesk.Revit.DB.FamilyInstance); (internalPos * UnitConverter.HostToDynamoFactor(SpecTypeId.Length)).ShouldBeApproximately( Point.ByCoordinates(0, 1, 2)); }
public void CurvesAreSimilar_Lines() { var a = Point.ByCoordinates(0, 0); var b = Point.ByCoordinates(1, 1); var c = Point.ByCoordinates(2, 2); var line1 = Line.ByStartPointEndPoint(a, b); var line2 = Line.ByStartPointEndPoint(b, a); var line3 = Line.ByStartPointEndPoint(a, c); var revitLine1 = line1.ToRevitType(); var revitLine2 = line2.ToRevitType(); var revitLine3 = line3.ToRevitType(); Assert.True(CurveUtils.CurvesAreSimilar(revitLine1, revitLine1)); Assert.False(CurveUtils.CurvesAreSimilar(revitLine1, revitLine2)); Assert.False(CurveUtils.CurvesAreSimilar(revitLine1, revitLine3)); }
public static Dictionary <string, object> LocationData(global::Revit.Elements.Element viewport) { Autodesk.Revit.DB.Document doc = DocumentManager.Instance.CurrentDBDocument; //obtain the element id from the sheet Autodesk.Revit.DB.Viewport internalViewport = (Autodesk.Revit.DB.Viewport)viewport.InternalElement; //obtain the box center of the viewport var boxCenterInternal = internalViewport.GetBoxCenter().ToPoint(); //Construct new point at sheet elevation of 0 Autodesk.DesignScript.Geometry.Point boxCenter = Autodesk.DesignScript.Geometry.Point.ByCoordinates(boxCenterInternal.X, boxCenterInternal.Y, 0); //this obtains the box outline var boxOutline = internalViewport.GetBoxOutline(); var bBox = BoundingBox.ByCorners(boxOutline.MaximumPoint.ToPoint(), boxOutline.MinimumPoint.ToPoint()); var boxCuboid = Cuboid.ByCorners(boxOutline.MaximumPoint.ToPoint(), boxOutline.MinimumPoint.ToPoint()); //create plane that corresponds to sheet plane Plane boxPlane = Plane.ByOriginNormal(boxOutline.MaximumPoint.ToPoint(), Vector.ZAxis()); var boxSurface = boxCuboid.Intersect(boxPlane); List <Autodesk.DesignScript.Geometry.Curve[]> boxCurves = new List <Autodesk.DesignScript.Geometry.Curve[]>(); foreach (Surface surf in boxSurface) { boxCurves.Add(surf.PerimeterCurves()); } List <Autodesk.DesignScript.Geometry.Curve> boxSheetCurves = new List <Autodesk.DesignScript.Geometry.Curve>(); //pull the curves onto a plane at 0,0,0 foreach (Autodesk.DesignScript.Geometry.Curve[] curve in boxCurves) { foreach (Autodesk.DesignScript.Geometry.Curve c in curve) { boxSheetCurves.Add(c.PullOntoPlane(Plane.XY())); } } //returns the outputs var outInfo = new Dictionary <string, object> { { "bBox", bBox }, { "boxCenter", boxCenter }, { "boxOutline", boxSheetCurves } }; return(outInfo); }
public static List <Point> ByCoordinateSystems(IEnumerable <BoundingBox> boundingBoxes, double width, double height, double gap) { var locs = new List <Point>(); var packer = new CygonRectanglePacker(width, height); foreach (var bbox in boundingBoxes) { var packLocation = UV.ByCoordinates(); var w = bbox.MaxPoint.X - bbox.MinPoint.X + gap; var h = bbox.MaxPoint.Y - bbox.MinPoint.Y + gap; if (packer.TryPack(w, h, out packLocation)) { locs.Add(Point.ByCoordinates(packLocation.U, packLocation.V, 0)); } } return(locs); }
/// <summary> /// Implements the MouseMove event handler for the manipulator /// </summary> /// <param name="sender"></param> /// <param name="mouseEventArgs"></param> protected virtual void MouseMove(object sender, MouseEventArgs mouseEventArgs) { if (!IsEnabled()) { return; } var clickRay = BackgroundPreviewViewModel.GetClickRay(mouseEventArgs); if (clickRay == null) { return; } if (GizmoInAction == null) { HighlightGizmoOnRollOver(clickRay); return; } var offset = GizmoInAction.GetOffset(clickRay.GetOriginPoint(), clickRay.GetDirectionVector()); if (offset.Length < 0.01) { return; } if (originAfterMove != null) { var offsetPos = originAfterMove.Add(offset); originAfterMove.Dispose(); originAfterMove = offsetPos; } // Update input nodes attached to manipulator node // Doing this triggers a graph update on scheduler thread OnGizmoMoved(GizmoInAction, offset); // redraw manipulator at new position synchronously var packages = BuildRenderPackage(); BackgroundPreviewViewModel.AddGeometryForRenderPackages(packages); }
public static DS.Circle GetAsCircle(this DS.Curve curve) { if (!curve.IsClosed) { throw new ArgumentException("Curve is not closed, cannot be a Circle"); } DS.Point start = curve.StartPoint; using (DS.Point midPoint = curve.PointAtParameter(0.5)) using (DS.Point centre = DS.Point.ByCoordinates(Median(start.X, midPoint.X), Median(start.Y, midPoint.Y), Median(start.Z, midPoint.Z))) { return(DS.Circle.ByCenterPointRadiusNormal( centre, centre.DistanceTo(start), curve.Normal )); } }
public void Circle_Basic() { var radius = 4; var circ = Autodesk.DesignScript.Geometry.Circle.ByCenterPointRadiusNormal( Point.ByCoordinates(1, 2, 3), radius, Vector.ByCoordinates(0, 0, 1)); var revitCurve = circ.ToRevitType(); Assert.NotNull(revitCurve); Assert.IsAssignableFrom <Autodesk.Revit.DB.Arc>(revitCurve); var revitArc = (Autodesk.Revit.DB.Arc)revitCurve; circ.CenterPoint.AssertShouldBeApproximately(revitArc.Center.ToPoint()); circ.Radius.AssertShouldBeApproximately(revitArc.Radius); circ.Normal.AssertShouldBeApproximately(revitArc.Normal.ToVector()); }
/// <summary> /// Create Advance Steel Variable Grating by Dynamo Rectangle and Point and Vectors /// </summary> /// <param name="origin"> Input Dynamo Point</param> /// <param name="xVector"> Input Dynamo X Vector</param> /// <param name="yVector"> Input Dynamo Y Vector</param> /// <param name="gratingClass"> Input Grating Class</param> /// <param name="gratingName"> Input Grating Size</param> /// <param name="width"> Input Grating Width</param> /// <param name="length"> Input Grating Length</param> /// <param name="additionalGratingParameters"> Optional Input Grating Build Properties </param> /// <returns name="variableGrating"> grating</returns> public static VariableGrating ByRectangularByPointAndVectors(Autodesk.DesignScript.Geometry.Point origin, Autodesk.DesignScript.Geometry.Vector xVector, Autodesk.DesignScript.Geometry.Vector yVector, string gratingClass, string gratingName, double width, double length, [DefaultArgument("null")] List <Property> additionalGratingParameters) { Autodesk.DesignScript.Geometry.CoordinateSystem coordinateSystem = Autodesk.DesignScript.Geometry.CoordinateSystem.ByOriginVectors(origin, xVector, yVector); additionalGratingParameters = PreSetDefaults(additionalGratingParameters, gratingClass, gratingName); return(new VariableGrating(Utils.ToAstPoint(coordinateSystem.Origin, true), Utils.ToAstVector3d(coordinateSystem.ZAxis, true), Utils.ToInternalDistanceUnits(width, true), Utils.ToInternalDistanceUnits(length, true), additionalGratingParameters)); }
Geo.Line GetMemberLineR(int faceIndex, int edgeIndex, bool rightHand) { Geo.Point p1 = mesh.faces[faceIndex].vertices[edgeIndex].ToPoint(); Geo.Point p2 = mesh.faces[faceIndex].vertices[(edgeIndex + 1) % 4].ToPoint(); Geo.Point p3 = mesh.faces[faceIndex].vertices[(edgeIndex + 2) % 4].ToPoint(); Geo.Point memberPoint = GetMemberPointOnEdge(faceIndex, edgeIndex, rightHand); Geo.Point nextMemberPoint = GetMemberPointOnEdge(faceIndex, (edgeIndex + 1) % 4, rightHand); Geo.Vector v1 = Geo.Vector.ByTwoPoints(p2, p1); Geo.Vector v2 = Geo.Vector.ByTwoPoints(p2, p3); double l = p2.DistanceTo(nextMemberPoint); double x = p2.DistanceTo(memberPoint); double a = 90 - v1.AngleWithVector(v2); a = (a * (Math.PI / 180)); double d1 = x / (Math.Tan(a)); double d2 = (x / Math.Sin(a)) - l; double d3 = Math.Cos(a); double length = d1 - (d2 / d3); Geo.Vector direction = v1.Cross(v1.Cross(v2)); direction = direction.Reverse(); var returnLine = Geo.Line.ByStartPointDirectionLength(memberPoint, direction, length); // Dispose /*{ * p1.Dispose(); * p2.Dispose(); * p3.Dispose(); * memberPoint.Dispose(); * nextMemberPoint.Dispose(); * v1.Dispose(); * v2.Dispose(); * direction.Dispose(); * }*/ return(returnLine); }
public static Point PolygonCentroidByPoints(IList <Point> vertices) { var cx = 0.0; var cy = 0.0; double signedArea = 0.0; double x0 = 0.0; // Current vertex X double y0 = 0.0; // Current vertex Y double x1 = 0.0; // Next vertex X double y1 = 0.0; // Next vertex Y double a = 0.0; // Partial signed area // For all vertices except last int i = 0; for (i = 0; i < vertices.Count - 1; ++i) { x0 = vertices[i].X; y0 = vertices[i].Y; x1 = vertices[i + 1].X; y1 = vertices[i + 1].Y; a = x0 * y1 - x1 * y0; signedArea += a; cx += (x0 + x1) * a; cy += (y0 + y1) * a; } // Do last vertex x0 = vertices[i].X; y0 = vertices[i].Y; x1 = vertices[0].X; y1 = vertices[0].Y; a = x0 * y1 - x1 * y0; signedArea += a; cx += (x0 + x1) * a; cy += (y0 + y1) * a; signedArea *= 0.5; cx /= (6.0 * signedArea); cy /= (6.0 * signedArea); return(Point.ByCoordinates(cx, cy, vertices[0].Z)); }
public static bool IsArc(this DS.Curve curve) { try { if (curve.IsClosed) { return(false); } using (DS.Point midPoint = curve.PointAtParameter(0.5)) using (DS.Arc arc = DS.Arc.ByThreePoints(curve.StartPoint, midPoint, curve.EndPoint)) { return(Threshold(arc.Length, curve.Length)); } } catch (Exception e) { return(false); } }
public static bool IsCircle(this DS.Curve curve) { try { if (!curve.IsClosed) { return(false); } using (DS.Point midPoint = curve.PointAtParameter(0.5)) { double radius = curve.StartPoint.DistanceTo(midPoint) * 0.5; return(Threshold(radius, (curve.Length) / (2 * Math.PI))); } } catch (Exception e) { return(false); } }
public static List <CoordinateSystem> CoordinateSystem(Revit.Elements.Element[] LinkInstance) { List <CoordinateSystem> coordinates = new List <CoordinateSystem>(); var doc = DocumentManager.Instance.CurrentDBDocument; foreach (Revit.Elements.Element i in LinkInstance) { ElementId elementId = Spring.Elements.UnwrapElement(i); RevitLinkInstance elem = doc.GetElement(elementId) as RevitLinkInstance; Autodesk.Revit.DB.Document linkDoc = elem.GetLinkDocument(); Transform transform = elem.GetTransform(); Autodesk.DesignScript.Geometry.Point point = transform.Origin.ToPoint(true); Vector bx = transform.BasisX.ToVector(); Vector by = transform.BasisY.ToVector(); Vector bz = transform.BasisZ.ToVector(); CoordinateSystem x = Autodesk.DesignScript.Geometry.CoordinateSystem.ByOriginVectors(point, bx, by, bz); coordinates.Add(x); } return(coordinates); }
/// <summary> /// Implements the MouseDown event handler for the manipulator /// </summary> /// <param name="sender"></param> /// <param name="mouseButtonEventArgs"></param> protected virtual void MouseDown(object sender, MouseButtonEventArgs mouseButtonEventArgs) { UpdatePosition(); GizmoInAction = null; //Reset Drag. var gizmos = GetGizmos(false); if (!IsEnabled() || null == gizmos || !gizmos.Any()) { return; } var ray = BackgroundPreviewViewModel.GetClickRay(mouseButtonEventArgs); if (ray == null) { return; } foreach (var item in gizmos) { using (var originPt = ray.GetOriginPoint()) using (var dirVec = ray.GetDirectionVector()) { object hitObject; if (item.HitTest(originPt, dirVec, out hitObject)) { GizmoInAction = item; var nodes = OnGizmoClick(item, hitObject).ToList(); if (nodes.Any()) { WorkspaceModel.RecordModelsForModification(nodes); } newPosition = Origin; return; } } } }
public void ToRevitType_ExtensionMethod_DoesExpectedUnitConversion() { // testing var pts = new[] { Point.ByCoordinates(10, 2, 3) , Point.ByCoordinates(0, 2, 2) , Point.ByCoordinates(10, 4, 8) , Point.ByCoordinates(10, 2, 8) , Point.ByCoordinates(5, 5, 5) }; var bspline = NurbsCurve.ByControlPoints(pts, 3); // do scaling for check var metersToFeet = 1 / 0.3048; var bsplineScaled = (NurbsCurve)bspline.Scale(metersToFeet); // by default, performs conversion var revitCurve = bspline.ToRevitType(); Assert.NotNull(revitCurve); Assert.IsAssignableFrom <Autodesk.Revit.DB.NurbSpline>(revitCurve); var revitSpline = (Autodesk.Revit.DB.NurbSpline)revitCurve; Assert.AreEqual(bsplineScaled.Degree, revitSpline.Degree); Assert.AreEqual(bsplineScaled.ControlPoints().Count(), revitSpline.CtrlPoints.Count); // We tesselate but not convert units. We are trying to find out if // ToRevitType did the conversion properly by comparing to a scaled // version of the original bspline (bsplineScaled) var tessPts = revitSpline.Tessellate().Select(x => x.ToPoint(false)); //assert the tesselation is very close to original curve foreach (var pt in tessPts) { var closestPt = bsplineScaled.ClosestPointTo(pt); Assert.Less(closestPt.DistanceTo(pt), 1e-6); } }
/// <summary> /// Create a Reference Point Element offset from a point along a vector /// </summary> /// <param name="basePoint"></param> /// <param name="direction"></param> /// <param name="distance"></param> /// <returns></returns> public static ReferencePoint ByPointVectorDistance(Point basePoint, Vector direction, double distance) { if (!Document.IsFamilyDocument) { throw new Exception("ReferencePoint Elements can only be created in a Family Document"); } if (basePoint == null) { throw new ArgumentNullException("basePoint"); } if (direction == null) { throw new ArgumentNullException("direction"); } var pt = (Point)basePoint.Translate(direction.Scale(distance)); return(new ReferencePoint(pt.ToXyz())); }
/// <summary> /// Creates a Conduit by a curve. /// </summary> /// <param name="conduitType">Type of the conduit.</param> /// <param name="curve">The curve.</param> /// <returns></returns> public static Conduit ByCurve(Revit.Elements.Element conduitType, Autodesk.DesignScript.Geometry.Curve curve) { Utils.Log(string.Format("Conduit.ByCurve started...", "")); var totalTransform = RevitUtils.DocumentTotalTransform(); UtilsObjectsLocation.CheckParameters(DocumentManager.Instance.CurrentDBDocument); var oType = conduitType.InternalElement as Autodesk.Revit.DB.Electrical.ConduitType; Autodesk.DesignScript.Geometry.Point start = curve.StartPoint.Transform(totalTransform) as Autodesk.DesignScript.Geometry.Point; var s = start.ToXyz(); Autodesk.DesignScript.Geometry.Point end = curve.EndPoint.Transform(totalTransform) as Autodesk.DesignScript.Geometry.Point; var e = end.ToXyz(); totalTransform.Dispose(); Utils.Log(string.Format("Conduit.ByCurve completed.", "")); return(new Conduit(oType, s, e)); }
public void ByGeometry_ProvidesExpectedConversion() { // construct the cuboid in meters var c0 = Point.ByCoordinates(-1, -1, -1); var c1 = Point.ByCoordinates(1, 1, 1); var cuboid = Cuboid.ByCorners(c0, c1); // import var import = Revit.Elements.ImportInstance.ByGeometry(cuboid); // extract geometry var importGeometry = import.Geometry().First(); Assert.IsAssignableFrom(typeof(Autodesk.DesignScript.Geometry.Solid), importGeometry); var solidImport = (Autodesk.DesignScript.Geometry.Solid)importGeometry; cuboid.Volume.ShouldBeApproximately(solidImport.Volume); cuboid.BoundingBox.MinPoint.ShouldBeApproximately(solidImport.BoundingBox.MinPoint); cuboid.BoundingBox.MaxPoint.ShouldBeApproximately(solidImport.BoundingBox.MaxPoint); }
public void ByNameNumberTitleBlockAndView_ValidArgs() { ElementBinder.IsEnabled = false; var famSymName = "E1 30x42 Horizontal"; var famName = "E1 30 x 42 Horizontal"; var titleBlock = FamilySymbol.ByFamilyAndName(Family.ByName(famName), famSymName); var famSym = FamilySymbol.ByName("Kousa Dogwood - 10'"); var pt = Point.ByCoordinates(0, 1, 2); var famInst = FamilyInstance.ByPoint(famSym, pt); var view = SectionView.ByBoundingBox(famInst.BoundingBox); var sheetName = "Poodle"; var sheetNumber = "A1"; var ele = Sheet.ByNameNumberTitleBlockAndView(sheetName, sheetNumber, titleBlock, view); Assert.NotNull(ele); }
public void ByCurveAndEqualDivisions_InvalidDivisions() { // create spline var pts = new Autodesk.DesignScript.Geometry.Point[] { Point.ByCoordinates(0,0,0), Point.ByCoordinates(1,0,0), Point.ByCoordinates(3,0,0), Point.ByCoordinates(10,0,0), Point.ByCoordinates(12,0,0), }; var spline = NurbsCurve.ByControlPoints(pts, 3); Assert.NotNull(spline); // build model curve from spline var modCurve = ModelCurve.ByCurve(spline); Assert.NotNull(modCurve); // build dividedPath Assert.Throws(typeof(Exception), () => DividedPath.ByCurveAndDivisions(modCurve.CurveReference, 0)); }
public void ByCurveAndEqualDivisions_ValidArgs() { // create spline var pts = new Autodesk.DesignScript.Geometry.Point[] { Point.ByCoordinates(0,0,0), Point.ByCoordinates(1,0,0), Point.ByCoordinates(3,0,0), Point.ByCoordinates(10,0,0), Point.ByCoordinates(12,0,0), }; var spline = NurbsCurve.ByControlPoints( pts, 3 ); Assert.NotNull(spline); // build model curve from spline var modCurve = ModelCurve.ByCurve(spline); Assert.NotNull(modCurve); // build dividedPath var divPath = DividedPath.ByCurveAndDivisions(modCurve.CurveReference, 5); Assert.NotNull(divPath); }
/// <summary> /// Create an AdaptiveComponent from a list of points. /// </summary> /// <param name="points">The points to reference in the AdaptiveComponent</param> /// <param name="familySymbol">The family symbol to use to build the AdaptiveComponent</param> /// <returns></returns> public static AdaptiveComponent ByPoints( Point[] points, FamilySymbol familySymbol ) { if (points == null) { throw new ArgumentNullException("points"); } if (familySymbol == null) { throw new ArgumentNullException("familySymbol"); } return new AdaptiveComponent(points, familySymbol); }
private static IConeEntity ByStartPointEndPointRadiusCore(Point startPoint, Point endPoint, double startRadius, double endRadius) { if (startRadius.LessThanOrEqualTo(0.0)) throw new System.ArgumentException(string.Format(Properties.Resources.LessThanZero, "start radius"), "startRadius"); if (endRadius < 0.0) throw new System.ArgumentException(string.Format(Properties.Resources.LessThanZero, "end radius"), "endRadius"); if (null == startPoint) throw new System.ArgumentNullException("startPoint"); if (null == endPoint) throw new System.ArgumentNullException("endPoint"); if (startPoint.DistanceTo(endPoint).EqualsTo(0.0)) throw new System.ArgumentException(string.Format(Properties.Resources.IsZeroDistance, "start point", "end point"), "startPoint, endPoint"); IConeEntity entity = HostFactory.Factory.ConeByPointsRadius(startPoint.PointEntity, endPoint.PointEntity, startRadius, endRadius); if (null == entity) throw new System.Exception(string.Format(Properties.Resources.OperationFailed, "Cone.ByStartPointEndPointRadius")); return entity; }
/// <summary> /// Construct a Surface by revolving the profile curve about an axis /// defined by axisOrigin point and axisDirection Vector. startAngle /// determines where the curve starts to revolve, sweepAngle determines /// the extent of the revolve. /// </summary> /// <param name="profile">Profile Curve for revolve surface.</param> /// <param name="axisOrigin">Origin Point for axis of revolution.</param> /// <param name="axisDirection">Direction Vector for axis of revolution.</param> /// <param name="startAngle">Start Angle in degreee at which curve starts to revolve.</param> /// <param name="sweepAngle">Sweep Angle in degree to define the extent of revolve.</param> /// <returns>RevolvedSurface</returns> public static RevolvedSurface ByProfileAxisOriginDirectionAngle(Curve profile, Point axisOrigin, Vector axisDirection, double startAngle, double sweepAngle) { return new RevolvedSurface(profile, axisOrigin, axisDirection, startAngle, sweepAngle, true); }
private static ISurfaceEntity ByProfileAxisOriginDirectionAngleCore(Curve profile, Point axisOrigin, Vector axisDirection, double startAngle, double sweepAngle) { if (null == profile) throw new System.ArgumentException(string.Format(Properties.Resources.NullArgument, "profile"), "profile"); if (null == axisOrigin) throw new System.ArgumentException(string.Format(Properties.Resources.NullArgument, "axis origin"), "axisOrigin"); if (null == axisDirection) throw new System.ArgumentException(string.Format(Properties.Resources.NullArgument, "axis direction"), "axisDirection"); ISurfaceEntity entity = HostFactory.Factory.SurfaceByRevolve(profile.CurveEntity, axisOrigin.PointEntity, axisDirection.IVector, startAngle, sweepAngle); if (entity == null) throw new System.Exception(string.Format(Properties.Resources.OperationFailed, "Surface.Revolve")); return entity; }
private static Line LineBetweenPoints(Point origin, double scale, System.Windows.Point a, System.Windows.Point b) { var pt1 = Point.ByCoordinates((a.X * scale) + origin.X, ((-a.Y + 1) * scale) + origin.Y, origin.Z); var pt2 = Point.ByCoordinates((b.X * scale) + origin.X, ((-b.Y + 1) * scale) + origin.Y, origin.Z); var crv = Line.ByStartPointEndPoint(pt1, pt2); return crv; }
/// <summary> /// Construct a Surface by revolving the profile curve about an axis /// defined by axisOrigin point and axisDirection Vector. /// Assuming sweep angle = 360 and start angle = 0. /// </summary> /// <param name="profile">Profile Curve for revolve surface.</param> /// <param name="axisOrigin">Origin Point for axis of revolution.</param> /// <param name="axisDirection">Direction Vector for axis of revolution.</param> /// <returns>RevolvedSurface</returns> public static RevolvedSurface ByProfileAxisOriginDirection(Curve profile, Point axisOrigin, Vector axisDirection) { return new RevolvedSurface(profile, axisOrigin, axisDirection, 0, 360, true); }
public static Line ToOriginCenteredLine(Point origin, Vector axis) { return Line.ByStartPointEndPoint(origin.Add(axis.Scale(-axisScaleFactor)), origin.Add(axis.Scale(axisScaleFactor))); }
/// <summary> /// Constructs a solid cone defined by a start and end point on its axis and the start and end radii of its base and top respectively. /// </summary> /// <param name="startPoint">The start point on the axis of the cone</param> /// <param name="endPoint">The end point on the axis of the cone</param> /// <param name="startRadius">The radius of the base of the cone</param> /// <param name="endRadius">The radius of the top of the cone</param> /// <returns></returns> public static Cone ByStartPointEndPointRadius(Point startPoint, Point endPoint, double startRadius, double endRadius) { return new Cone(startPoint, endPoint, startRadius, endRadius, true); }
/// <summary> /// Callback method when gizmo is moved by user action. /// </summary> /// <param name="gizmo">Gizmo that moved.</param> /// <param name="offset">Offset by which the gizmo has moved.</param> /// <returns>New expected position of the Gizmo</returns> protected override Point OnGizmoMoved(IGizmo gizmo, Vector offset) { expectedPosition = origin.Add(offset); foreach (var item in indexedAxisNodePairs) { // When more than one input is connected to the same slider, this // method will decompose the axis corresponding to each input. var v = GetFirstAxisComponent(item.Value.Item1); var amount = Math.Round(offset.Dot(v), 3); if (Math.Abs(amount) > 0.001) ModifyInputNode(item.Value.Item2, amount); } return expectedPosition; }
/// <summary> /// Synchronize the origin with the node's value. /// </summary> protected override void UpdatePosition() { Active = false; if (Node == null || !indexedAxisNodePairs.Any()) return; if (origin == null) { origin = Point.Origin(); } // hack: to prevent node mirror value lookup from throwing an exception var previousOrigin = Point.ByCoordinates(origin.X, origin.Y, origin.Z); try { //Node output could be a collection, consider the first item as origin. Point pt = GetFirstValueFromNode(Node) as Point; origin = pt != null ? Point.ByCoordinates(pt.X, pt.Y, pt.Z) : origin; } catch (Exception) { origin = previousOrigin; } if (origin == null) { origin = Point.Origin(); return; } Active = true; }
/// <summary> /// Implements the MouseDown event handler for the manipulator /// </summary> /// <param name="sender"></param> /// <param name="mouseButtonEventArgs"></param> protected virtual void MouseDown(object sender, MouseButtonEventArgs mouseButtonEventArgs) { UpdatePosition(); GizmoInAction = null; //Reset Drag. var gizmos = GetGizmos(false); if (!Active || !IsEnabled() || null == gizmos || !gizmos.Any()) return; var ray = BackgroundPreviewViewModel.GetClickRay(mouseButtonEventArgs); if (ray == null) return; foreach (var item in gizmos) { using(var originPt = ray.GetOriginPoint()) using (var dirVec = ray.GetDirectionVector()) { object hitObject; if (item.HitTest(originPt, dirVec, out hitObject)) { GizmoInAction = item; var nodes = OnGizmoClick(item, hitObject).ToList(); if (nodes.Any()) { WorkspaceModel.RecordModelsForModification(nodes); } newPosition = Origin; return; } } } }
/// <summary> /// Implements the MouseMove event handler for the manipulator /// </summary> /// <param name="sender"></param> /// <param name="mouseEventArgs"></param> protected virtual void MouseMove(object sender, MouseEventArgs mouseEventArgs) { if (!IsEnabled()) return; var clickRay = BackgroundPreviewViewModel.GetClickRay(mouseEventArgs); if (clickRay == null) return; if (GizmoInAction == null) { HighlightGizmoOnRollOver(clickRay); return; } if (!CanMoveGizmo(GizmoInAction)) return; var offset = GizmoInAction.GetOffset(clickRay.GetOriginPoint(), clickRay.GetDirectionVector()); if (offset.Length < 0.01) return; newPosition = OnGizmoMoved(GizmoInAction, offset); }
public void GetDegreesOfFreedom(out int translationDegreesCount, out ObjectsEnumerator translationDegreesVectors, out int rotationDegreesCount, out ObjectsEnumerator rotationDegreesVectors, out Point dOFCenter) { InternalGetDegreesOfFreedom(out translationDegreesCount, out translationDegreesVectors, out rotationDegreesCount, out rotationDegreesVectors, out dOFCenter); }
private void InternalGetDegreesOfFreedom(out int translationDegreesCount, out ObjectsEnumerator translationDegreesVectors, out int rotationDegreesCount, out ObjectsEnumerator rotationDegreesVectors, out Point dOFCenter) { Inventor.Point dOFCenterInv; ComponentOccurrenceInstance.GetDegreesOfFreedom(out translationDegreesCount, out translationDegreesVectors, out rotationDegreesCount, out rotationDegreesVectors, out dOFCenterInv); dOFCenter = dOFCenterInv.ToPoint(); }
//perhaps move to BuildingSurface? /// <summary> /// /// </summary> /// <param name="surfaces"></param> /// <param name="zone"></param> /// <param name="centerpoint"></param> public static List<BuildingSurface> BuildingSurfacesByOrientation(List<Surface> surfaces, Zone zone, Point centerpoint) { var buildingSurfaces = new List<BuildingSurface>(); foreach (var surface in surfaces) if (surface.NormalAtParameter(0.5, 0.5).AngleBetween(Vector.ByCoordinates(0, 0, 1)) < 0.01) { buildingSurfaces.Add(surface.PointAtParameter(0.5, 0.5).Z > centerpoint.Z ? new BuildingSurface(surface, zone, "default", "Roof") : new BuildingSurface(surface, zone, "default", "Floor", "default", "Ground")); } else { buildingSurfaces.Add(new BuildingSurface(surface, zone)); } //Not working as intended... //foreach (var Surface in geometry) //{ // if (GetNormal(Surface).IsAlmostEqualTo(Vector.ByCoordinates(0, 0, 1))) // { // buildingSurfaces.Add(new BuildingSurface(Surface, zone, "default", "Roof")); // } // else if (GetNormal(Surface).IsAlmostEqualTo(Vector.ByCoordinates(0, 0, -1))) // { // buildingSurfaces.Add(new BuildingSurface(Surface, zone, "default", "Floor")); // } // else // { // buildingSurfaces.Add(new BuildingSurface(Surface, zone)); // } //} return buildingSurfaces; }