Curve
using Autodesk.DesignScript.Geometry.Properties;
using Autodesk.DesignScript.Interfaces;
using Autodesk.DesignScript.Runtime;
using System;
using System.Collections.Generic;
using System.Linq;
namespace Autodesk.DesignScript.Geometry
{
public class Curve : Geometry
{
internal ICurveEntity CurveEntity => HostImpl as ICurveEntity;
[Scaling()]
public virtual double Length {
get {
return CurveEntity.get_Length() * DesignScriptEntity.scaleFactor;
}
}
public virtual bool IsPlanar => CurveEntity.get_IsPlanar();
public virtual bool IsClosed => CurveEntity.get_IsClosed();
public virtual Point StartPoint => Point.Wrap(CurveEntity.get_StartPoint());
public virtual Point EndPoint => Point.Wrap(CurveEntity.get_EndPoint());
[Scaling()]
public virtual Vector Normal {
get {
return Vector.Wrap(CurveEntity.get_Normal().Scale(1 / DesignScriptEntity.scaleFactor));
}
}
internal Curve(ICurveEntity host)
: base(host)
{
}
public override string ToString()
{
return "Curve(StartPoint = " + StartPoint?.ToString() + ", EndPoint = " + EndPoint?.ToString() + ")";
}
internal static void InitType()
{
Geometry.RegisterHostType(typeof(ICurveEntity), (IGeometryEntity host) => new Curve(host as ICurveEntity));
}
internal static Curve Wrap(ICurveEntity host)
{
return Geometry.Wrap(host, null) as Curve;
}
internal static Curve[] Wrap(ICurveEntity[] hosts)
{
return (from x in hosts
select Wrap(x)).ToArray();
}
internal static Curve[][] Wrap(ICurveEntity[][] hosts)
{
return (from x in hosts
select Wrap(x)).ToArray();
}
internal static ICurveEntity[][] Unwrap(Curve[][] o)
{
return (from x in o
select Unwrap(x)).ToArray();
}
internal static ICurveEntity[] Unwrap(Curve[] o)
{
return (from x in o
select Unwrap(x)).ToArray();
}
internal static ICurveEntity[] Unwrap(IEnumerable<Curve> o)
{
return (from x in o
select Unwrap(x)).ToArray();
}
internal static ICurveEntity Unwrap(Curve o)
{
return o.CurveEntity;
}
public static Curve ByParameterLineOnSurface(Surface baseSurface, UV startParams, UV endParams)
{
return Wrap(HostFactory.Factory.CurveByParameterLineOnSurface(Surface.Unwrap(baseSurface), UV.Unwrap(startParams), UV.Unwrap(endParams)));
}
public static Curve ByBlendBetweenCurves(Curve curve1, Curve curve2, bool endOrStart1 = true, bool endOrStart2 = false, bool isG2Continuous = false)
{
return Wrap(HostFactory.Factory.CurveByBlendBetweenCurves(Unwrap(curve1), Unwrap(curve2), endOrStart1, endOrStart2, isG2Continuous));
}
public static Curve ByIsoCurveOnSurface(Surface baseSurface, int direction = 0, double parameter = 0)
{
return Wrap(HostFactory.Factory.CurveByIsoCurveOnSurface(Surface.Unwrap(baseSurface), direction, parameter));
}
public virtual Point PointAtParameter(double param = 0)
{
return Point.Wrap(CurveEntity.PointAtParameter(param));
}
[Scaling()]
public virtual Vector TangentAtParameter(double param = 0)
{
return Vector.Wrap(CurveEntity.TangentAtParameter(param).Scale(1 / DesignScriptEntity.scaleFactor));
}
[Scaling()]
public virtual Vector NormalAtParameter(double param = 0)
{
return Vector.Wrap(CurveEntity.NormalAtParameter(param).Scale(1 / DesignScriptEntity.scaleFactor));
}
[Scaling()]
public virtual Vector NormalAtParameter(double param = 0, bool side = false)
{
return Vector.Wrap(CurveEntity.NormalAtParameter(param, side).Scale(1 / DesignScriptEntity.scaleFactor));
}
public virtual CoordinateSystem CoordinateSystemAtParameter(double param = 0)
{
return CoordinateSystem.Wrap(CurveEntity.CoordinateSystemAtParameter(param));
}
public virtual CoordinateSystem HorizontalFrameAtParameter(double param = 0)
{
return CoordinateSystem.Wrap(CurveEntity.HorizontalFrameAtParameter(param));
}
public virtual Plane PlaneAtParameter(double param = 0)
{
return Plane.Wrap(CurveEntity.PlaneAtParameter(param));
}
public virtual Point PointAtSegmentLength([Scaling()] double segmentLength = 0)
{
DesignScriptEntity.CheckArgsForAsmExtents(new List<double> {
segmentLength
});
segmentLength /= DesignScriptEntity.scaleFactor;
return Point.Wrap(CurveEntity.PointAtSegmentLength(segmentLength));
}
public virtual Point[] PointsAtEqualSegmentLength(int divisions = 10)
{
return Point.Wrap(CurveEntity.PointsAtEqualSegmentLength(divisions));
}
public virtual Point[] PointsAtEqualChordLength(int divisions = 10)
{
return Point.Wrap(CurveEntity.PointsAtEqualChordLength(divisions));
}
public virtual Point PointAtChordLength([Scaling()] double chordLength = 1, double parameterLocation = 0, bool forward = true)
{
DesignScriptEntity.CheckArgsForAsmExtents(new List<double> {
chordLength
});
chordLength /= DesignScriptEntity.scaleFactor;
return Point.Wrap(CurveEntity.PointAtChordLength(chordLength, parameterLocation, forward));
}
public virtual Point[] PointsAtSegmentLengthFromPoint([DefaultArgument("Autodesk.DesignScript.Geometry.Point.ByCoordinates(0, 0, 0)")] Point point, [Scaling()] double segmentLength = 1)
{
DesignScriptEntity.CheckArgsForAsmExtents(new List<double> {
segmentLength
});
segmentLength /= DesignScriptEntity.scaleFactor;
return Point.Wrap(CurveEntity.PointsAtSegmentLengthFromPoint(Point.Unwrap(point), segmentLength));
}
public virtual Point[] PointsAtChordLengthFromPoint([DefaultArgument("Autodesk.DesignScript.Geometry.Point.ByCoordinates(0, 0, 0)")] Point point, [Scaling()] double chordLength = 1)
{
DesignScriptEntity.CheckArgsForAsmExtents(new List<double> {
chordLength
});
chordLength /= DesignScriptEntity.scaleFactor;
return Point.Wrap(CurveEntity.PointsAtChordLengthFromPoint(Point.Unwrap(point), chordLength));
}
public virtual CoordinateSystem CoordinateSystemAtSegmentLength([Scaling()] double segmentLength = 0)
{
DesignScriptEntity.CheckArgsForAsmExtents(new List<double> {
segmentLength
});
segmentLength /= DesignScriptEntity.scaleFactor;
return CoordinateSystem.Wrap(CurveEntity.CoordinateSystemAtSegmentLength(segmentLength));
}
public virtual Plane PlaneAtSegmentLength([Scaling()] double segmentLength = 0)
{
DesignScriptEntity.CheckArgsForAsmExtents(new List<double> {
segmentLength
});
segmentLength /= DesignScriptEntity.scaleFactor;
return Plane.Wrap(CurveEntity.PlaneAtSegmentLength(segmentLength));
}
[Scaling()]
public virtual double SegmentLengthAtParameter(double parameter = 0)
{
return CurveEntity.SegmentLengthAtParameter(parameter) * DesignScriptEntity.scaleFactor;
}
public virtual double ParameterAtSegmentLength([Scaling()] double segmentLength = 0)
{
DesignScriptEntity.CheckArgsForAsmExtents(new List<double> {
segmentLength
});
segmentLength /= DesignScriptEntity.scaleFactor;
return CurveEntity.ParameterAtSegmentLength(segmentLength);
}
public virtual double ParameterAtChordLength([Scaling()] double chordLength = 0.5, double parameter = 0, bool forward = true)
{
DesignScriptEntity.CheckArgsForAsmExtents(new List<double> {
chordLength
});
chordLength /= DesignScriptEntity.scaleFactor;
return CurveEntity.ParameterAtChordLength(chordLength, parameter, forward);
}
public virtual double StartParameter()
{
return CurveEntity.StartParameter();
}
public virtual double EndParameter()
{
return CurveEntity.EndParameter();
}
[Scaling()]
public virtual double SegmentLengthBetweenParameters(double startParam = 0, double endParam = 1)
{
return CurveEntity.SegmentLengthBetweenParameters(startParam, endParam) * DesignScriptEntity.scaleFactor;
}
public virtual double ParameterAtPoint(Point point)
{
return CurveEntity.ParameterAtPoint(Point.Unwrap(point));
}
public virtual Curve Reverse()
{
return Wrap(CurveEntity.Reverse());
}
[IsVisibleInDynamoLibrary(false)]
[IsObsolete("curve_offset_deprecated", typeof(Resources))]
[Obsolete("This method is deprecated and will be removed in a future version of Dynamo. Use 'OffsetMany' instead.")]
public Curve Offset([Scaling()] double distance = 1)
{
DesignScriptEntity.CheckArgsForAsmExtents(new List<double> {
distance
});
distance /= DesignScriptEntity.scaleFactor;
return Wrap(CurveEntity.Offset(distance));
}
[AllowRankReduction]
public Curve[] OffsetMany([DefaultArgument("1")] [Scaling()] double signedDistance, [DefaultArgument("null")] Vector planeNormal)
{
DesignScriptEntity.CheckArgsForAsmExtents(new List<double> {
signedDistance
});
signedDistance /= DesignScriptEntity.scaleFactor;
return Wrap(CurveEntity.OffsetMany(signedDistance, Vector.Unwrap(planeNormal)));
}
public Curve PullOntoPlane(Plane plane)
{
return Wrap(CurveEntity.PullOntoPlane(Plane.Unwrap(plane)));
}
public Curve PullOntoSurface(Surface surface)
{
return Wrap(CurveEntity.PullOntoSurface(Surface.Unwrap(surface)));
}
public Curve TrimByStartParameter(double startParameter = 0)
{
return Wrap(CurveEntity.TrimByStartParameter(startParameter));
}
public virtual Curve TrimByEndParameter(double endParameter = 1)
{
return Wrap(CurveEntity.TrimByEndParameter(endParameter));
}
public virtual Curve TrimByParameter(double startParameter = 0, double endParameter = 1)
{
return Wrap(CurveEntity.TrimByParameter(startParameter, endParameter));
}
public virtual Curve[] TrimInteriorByParameter(double startParameter = 0, double endParameter = 1)
{
return Wrap(CurveEntity.TrimInteriorByParameter(startParameter, endParameter));
}
[IsVisibleInDynamoLibrary(false)]
[IsObsolete("curve_trimsegmentsbyparam_deprecated", typeof(Resources))]
[Obsolete("This method is deprecated and will be removed in a future version of Dynamo. Use Curve.TrimSegmentsByParameter(double[] parameters, bool discardEvenSegments) instead.")]
public Curve[] TrimSegmentsByParameter(double[] parameters)
{
return Wrap(CurveEntity.TrimSegmentsByParameter(parameters));
}
public virtual Curve[] TrimSegmentsByParameter(double[] parameters, bool discardEvenSegments = true)
{
return Wrap(CurveEntity.TrimSegmentsByParameter(parameters, discardEvenSegments));
}
public virtual Curve[] SplitByParameter(double[] parameters)
{
return Wrap(CurveEntity.SplitByParameter(parameters));
}
public virtual Curve[] SplitByPoints(IEnumerable<Point> points)
{
return Wrap(CurveEntity.SplitByPoints(Point.Unwrap(points)));
}
public virtual PolyCurve Join(IEnumerable<Curve> curves)
{
return PolyCurve.Wrap(CurveEntity.Join(Unwrap(curves)));
}
public Surface Extrude([Scaling()] double distance = 1)
{
DesignScriptEntity.CheckArgsForAsmExtents(new List<double> {
distance
});
distance /= DesignScriptEntity.scaleFactor;
return Surface.Wrap(CurveEntity.Extrude(distance));
}
public Surface Extrude([DefaultArgument("Autodesk.DesignScript.Geometry.Vector.ByCoordinates(0, 0, 1)")] Vector direction)
{
return Surface.Wrap(CurveEntity.Extrude(Vector.Unwrap(direction)));
}
public Surface Extrude([DefaultArgument("Autodesk.DesignScript.Geometry.Vector.ByCoordinates(0, 0, 1)")] Vector direction, [Scaling()] double distance = 1)
{
DesignScriptEntity.CheckArgsForAsmExtents(new List<double> {
distance
});
distance /= DesignScriptEntity.scaleFactor;
return Surface.Wrap(CurveEntity.Extrude(Vector.Unwrap(direction), distance));
}
public Solid ExtrudeAsSolid([Scaling()] double distance = 1)
{
DesignScriptEntity.CheckArgsForAsmExtents(new List<double> {
distance
});
distance /= DesignScriptEntity.scaleFactor;
return Solid.Wrap(CurveEntity.ExtrudeAsSolid(distance));
}
public Solid ExtrudeAsSolid([DefaultArgument("Autodesk.DesignScript.Geometry.Vector.ByCoordinates(0, 0, 1)")] Vector direction)
{
return Solid.Wrap(CurveEntity.ExtrudeAsSolid(Vector.Unwrap(direction)));
}
public Solid ExtrudeAsSolid([DefaultArgument("Autodesk.DesignScript.Geometry.Vector.ByCoordinates(0, 0, 1)")] Vector direction, [Scaling()] double distance = 1)
{
DesignScriptEntity.CheckArgsForAsmExtents(new List<double> {
distance
});
distance /= DesignScriptEntity.scaleFactor;
return Solid.Wrap(CurveEntity.ExtrudeAsSolid(Vector.Unwrap(direction), distance));
}
public virtual Curve Extend([Scaling()] double distance, Point pickSide)
{
DesignScriptEntity.CheckArgsForAsmExtents(new List<double> {
distance
});
distance /= DesignScriptEntity.scaleFactor;
return Wrap(CurveEntity.Extend(distance, Point.Unwrap(pickSide)));
}
public virtual Curve ExtendStart([Scaling()] double distance = 1)
{
DesignScriptEntity.CheckArgsForAsmExtents(new List<double> {
distance
});
distance /= DesignScriptEntity.scaleFactor;
return Wrap(CurveEntity.ExtendStart(distance));
}
public virtual Curve ExtendEnd([Scaling()] double distance = 1)
{
DesignScriptEntity.CheckArgsForAsmExtents(new List<double> {
distance
});
distance /= DesignScriptEntity.scaleFactor;
return Wrap(CurveEntity.ExtendEnd(distance));
}
public virtual Curve[] ApproximateWithArcAndLineSegments()
{
return Wrap(CurveEntity.ApproximateWithArcAndLineSegments());
}
public NurbsCurve ToNurbsCurve()
{
return NurbsCurve.Wrap(CurveEntity.ToNurbsCurve());
}
public Surface Patch()
{
return Surface.Wrap(CurveEntity.Patch());
}
public Geometry[] Project(Geometry baseGeometry, Vector projectionDirection)
{
return Geometry.Wrap(CurveEntity.Project(Geometry.Unwrap(baseGeometry), Vector.Unwrap(projectionDirection)));
}
public Surface SweepAsSurface(Curve path)
{
return Surface.Wrap(CurveEntity.SweepAsSurface(Unwrap(path)));
}
[IsVisibleInDynamoLibrary(false)]
[IsObsolete("curve_sweepassolidsingle_deprecated", typeof(Resources))]
[Obsolete("This method is deprecated and will be removed in a future version of Dynamo. Use SweepAsSolid(ICurveEntity path, bool cutEndOff) instead")]
public Solid SweepAsSolid(Curve path)
{
return Solid.Wrap(CurveEntity.SweepAsSolid(Unwrap(path)));
}
public Solid SweepAsSolid(Curve path, bool cutEndOff = false)
{
return Solid.Wrap(CurveEntity.SweepAsSolid(Unwrap(path), cutEndOff));
}
public virtual Curve Simplify([Scaling()] double tolerance)
{
DesignScriptEntity.CheckArgsForAsmExtents(new List<double> {
tolerance
});
tolerance /= DesignScriptEntity.scaleFactor;
return Wrap(CurveEntity.Simplify(tolerance));
}
}
}