private Spiral AlignmentSpiralToSpeckle(CivilDB.AlignmentSubEntitySpiral spiral, CivilDB.Alignment alignment)
{
var _spiral = new Spiral();
_spiral.startPoint = PointToSpeckle(spiral.StartPoint);
_spiral.endPoint = PointToSpeckle(spiral.EndPoint);
_spiral.length = spiral.Length;
_spiral.pitch = 0;
_spiral.spiralType = SpiralTypeToSpeckle(spiral.SpiralDefinition);
// get plane
var vX = new Vector3d(System.Math.Cos(spiral.StartDirection) + spiral.StartPoint.X, System.Math.Sin(spiral.StartDirection) + spiral.StartPoint.Y, 0);
var vY = vX.RotateBy(System.Math.PI / 2, Vector3d.ZAxis);
var plane = new Acad.Plane(new Point3d(spiral.RadialPoint.X, spiral.RadialPoint.Y, 0), vX, vY);
_spiral.plane = PlaneToSpeckle(plane);
// get turns
int turnDirection = (spiral.Direction == CivilDB.SpiralDirectionType.DirectionLeft) ? 1 : -1;
_spiral.turns = turnDirection * spiral.Delta / (System.Math.PI * 2);
// create polyline display, default tessellation length is 1
var tessellation = 1;
int spiralSegmentCount = System.Convert.ToInt32(System.Math.Ceiling(spiral.Length / tessellation));
spiralSegmentCount = (spiralSegmentCount < 10) ? 10 : spiralSegmentCount;
double spiralSegmentLength = spiral.Length / spiralSegmentCount;
List <Point2d> points = new List <Point2d>();
points.Add(spiral.StartPoint);
for (int i = 1; i < spiralSegmentCount; i++)
{
double x = 0;
double y = 0;
double z = 0;
alignment.PointLocation(spiral.StartStation + (i * spiralSegmentLength), 0, tolerance, ref x, ref y, ref z);
points.Add(new Point2d(x, y));
}
points.Add(spiral.EndPoint);
double length = 0;
for (int j = 1; j < points.Count; j++)
{
length += points[j].GetDistanceTo(points[j - 1]);
}
var poly = new Polyline();
poly.value = PointsToFlatList(points);
poly.units = ModelUnits;
poly.closed = (spiral.StartPoint != spiral.EndPoint) ? false : true;
poly.length = length;
_spiral.displayValue = poly;
return(_spiral);
}
public Polyline3d PolylineToNativeDB(Polyline polyline) // AC polyline3d can only have linear segments
{
var vertices = new Point3dCollection();
for (int i = 0; i < polyline.points.Count; i++)
{
vertices.Add(PointToNative(polyline.points[i]));
}
return(new Polyline3d(Poly3dType.SimplePoly, vertices, polyline.closed));
}
// Splines
public Curve SplineToSpeckle(Spline spline)
{
var curve = new Curve();
// get nurbs and geo data
var data = spline.NurbsData;
var _spline = spline.GetGeCurve() as NurbCurve3d;
// handle the display polyline
try
{
var poly = spline.ToPolyline(false, true);
Polyline displayValue = ConvertToSpeckle(poly) as Polyline;
curve.displayValue = displayValue;
}
catch { }
// get weights: autocad assigns unweighted points a value of -1, and will return an empty list in the spline's nurbsdata if no points are weighted
var weights = new List <double>();
for (int i = 0; i < spline.NumControlPoints; i++)
{
double weight = spline.WeightAt(i);
if (weight < 0)
{
weights.Add(1);
}
else
{
weights.Add(weight);
}
}
// set nurbs curve info
curve.points = PointsToFlatArray(data.GetControlPoints().OfType <Point3d>().ToList()).ToList();
curve.knots = data.GetKnots().OfType <double>().ToList();
curve.weights = weights;
curve.degree = spline.Degree;
curve.periodic = spline.IsPeriodic;
curve.rational = spline.IsRational;
curve.closed = spline.Closed;
curve.length = _spline.GetLength(_spline.StartParameter, _spline.EndParameter, tolerance);
curve.domain = IntervalToSpeckle(_spline.GetInterval());
curve.bbox = BoxToSpeckle(spline.GeometricExtents, true);
curve.units = ModelUnits;
return(curve);
}
// Polycurve
// TODO: NOT TESTED FROM HERE DOWN
public PolylineCurve3d PolylineToNative(Polyline polyline)
{
var points = PointListToNative(polyline.value, polyline.units).ToList();
if (polyline.closed)
{
points.Add(points[0]);
}
var _polyline = new PolylineCurve3d(new Point3dCollection(points.ToArray()));
if (polyline.domain != null)
{
_polyline.SetInterval(IntervalToNative(polyline.domain));
}
return(_polyline);
}
public Polyline PolylineToSpeckle(AcadDB.Polyline3d polyline) // AC polyline3d can only have linear segments
{
List <Point3d> vertices = new List <Point3d>();
foreach (PolylineVertex3d vertex in polyline)
{
vertices.Add(vertex.Position);
}
if (polyline.Closed)
{
vertices.Add(vertices[0]);
}
var _polyline = new Polyline(PointsToFlatArray(vertices), ModelUnits);
_polyline.closed = polyline.Closed;
_polyline.length = polyline.Length;
_polyline.bbox = BoxToSpeckle(polyline.GeometricExtents, true);
return(_polyline);
}
// Polycurves
public Polyline PolylineToSpeckle(AcadDB.Polyline polyline) // AC polylines can have arc segments, this treats all segments as lines
{
List <Point3d> vertices = new List <Point3d>();
for (int i = 0; i < polyline.NumberOfVertices; i++)
{
vertices.Add(polyline.GetPoint3dAt(i));
}
if (polyline.Closed)
{
vertices.Add(polyline.GetPoint3dAt(0));
}
var _polyline = new Polyline(PointsToFlatArray(vertices), ModelUnits);
_polyline.closed = polyline.Closed;
_polyline.length = polyline.Length;
_polyline.bbox = BoxToSpeckle(polyline.GeometricExtents, true);
return(_polyline);
}
