/// <summary>
/// Draws the shading overhang by a list of Overhangs
/// </summary>
/// <param name="shadingOverhangsList"></param>
/// <returns></returns>
private static List <PolyCurve> Draw(List <ShadingOverhang> shadingOverhangsList)
{
var rectangles = new List <PolyCurve>();
foreach (ShadingOverhang shadingOverhang in shadingOverhangsList)
{
//expects fenestrationSurface to be defined like: 3 2
// 0 1
//find a coordinateSystem where the fenestration Surface lies in
var vec1 = Vector.ByTwoPoints(shadingOverhang.FenestrationSurface.Surface.Vertices[0].PointGeometry, shadingOverhang.FenestrationSurface.Surface.Vertices[1].PointGeometry);
var vec2 = Vector.ByTwoPoints(shadingOverhang.FenestrationSurface.Surface.Vertices[0].PointGeometry, shadingOverhang.FenestrationSurface.Surface.Vertices[3].PointGeometry);
var length = vec1.Length;
//calculate new points for the ShadingOverhang
var points = new List <Point>();
var coordSystem = CoordinateSystem.ByOriginVectors(shadingOverhang.FenestrationSurface.Surface.Vertices[3].PointGeometry, vec1, vec2);
points.Add(Point.ByCartesianCoordinates(coordSystem, -shadingOverhang.Extension, shadingOverhang.Height));
points.Add(Point.ByCartesianCoordinates(coordSystem, -shadingOverhang.Extension, shadingOverhang.Height, shadingOverhang.Depth));
points.Add(Point.ByCartesianCoordinates(coordSystem, length + shadingOverhang.Extension, shadingOverhang.Height, shadingOverhang.Depth));
points.Add(Point.ByCartesianCoordinates(coordSystem, length + shadingOverhang.Extension, shadingOverhang.Height));
PolyCurve rectangle = PolyCurve.ByPoints(points, true);
rectangles.Add(rectangle);
}//foreach
return(rectangles);
} //Draw ShadingOverhang
/// <summary>
/// SpecklePolyline to DS Rectangle if closed , four points and sides parallel;
/// DS Polygon if closed or DS Polycurve otherwise
/// </summary>
/// <param name="polyline"></param>
/// <returns></returns>
public static Curve ToNative(this SpecklePolyline polyline)
{
var points = polyline.Value.ToPoints();
var polycurve = PolyCurve.ByPoints(polyline.Value.ToPoints());
// If closed and planar, make polygon
if (polyline.Closed && polycurve.IsPlanar)
{
polycurve.Dispose(); // geometry not needed. Freeing memory.
double dot = Vector.ByTwoPoints(points[0], points[1]).Dot(Vector.ByTwoPoints(points[1], points[2]));
if (points.Count() == 4 && Threshold(dot, 0))
{
return(Rectangle.ByCornerPoints(points).SetSpeckleProperties <Rectangle>(polyline.Properties));
}
else
{
return(Polygon.ByPoints(polyline.Value.ToPoints()).SetSpeckleProperties <Polygon>(polyline.Properties));
}
}
else
{
return(polycurve.SetSpeckleProperties <PolyCurve>(polyline.Properties));
}
}
public static Autodesk.DesignScript.Geometry.PolyCurve ToProtoType(this Autodesk.Revit.DB.PolyLine geom,
bool performHostUnitConversion = true)
{
var converted = PolyCurve.ByPoints(geom.GetCoordinates().Select(x => Autodesk.DesignScript.Geometry.Point.ByCoordinates(x.X, x.Y, x.Z)).ToArray());
return(performHostUnitConversion ? converted.InDynamoUnits() : converted);
}
//MAKE POLYGON BASED ON POINT COORDS
public static PolyCurve PolyCurveFromPoints(List <Point2d> pointCoordList)
{
PolyCurve pCurve;
List <Point> pointList = new List <Point>();
for (int i = 0; i < pointCoordList.Count; i++)
{
pointList.Add(Point.ByCoordinates(pointCoordList[i].X, pointCoordList[i].Y));
if (i == pointCoordList.Count - 1)
{
pointList.Add(Point.ByCoordinates(pointCoordList[0].X, pointCoordList[0].Y));
}
}
try
{
pCurve = PolyCurve.ByPoints(pointList);
}
catch (System.Exception)
{
pCurve = null;
//throw;
}
return(pCurve);
}
/// <summary>
/// Private method to retrieve Baseline PolyCurves.
/// </summary>
/// <returns>A list of PolyCurves for each BaselineRegion.</returns>
/// <remarks>In case of large dataset, the Geometry Working Range wiill return a warning. Set the Geometry Working Range to Medium.</remarks>
private IList <PolyCurve> BaselinePolyCurves()
{
Utils.Log(string.Format("Baseline.BaselinePolyCurves started...", ""));
IList <PolyCurve> polyCurves = new List <PolyCurve>();
foreach (BaselineRegion blr in this.GetBaselineRegions())
{
IList <Point> baseLinePoints = new List <Point>();
foreach (double station in blr.Stations)
{
baseLinePoints.Add(this.PointByStationOffsetElevation(station, 0, 0));
}
polyCurves.Add(PolyCurve.ByPoints(baseLinePoints));
foreach (var p in baseLinePoints)
{
if (p != null)
{
p.Dispose();
}
}
}
Utils.Log(string.Format("Baseline.BaselinePolyCurves completed.", ""));
return(polyCurves);
}
public static Content.Annotation InkToPolyCurve(this PdfDictionary annotation)
{
PdfArray datarray = annotation.GetAsArray(PdfName.INKLIST);
if (datarray == null || datarray.Size == 0)
{
return(null);
}
PdfArray data = datarray[0] as PdfArray;
List <Point> points = new List <Point>();
for (int j = 0; j < data.Size - 1; j = j + 2)
{
points.Add(Point.ByCoordinates(data[j].ToDouble(), data[j + 1].ToDouble()));
}
if (points.First().IsAlmostEqualTo(points.Last()))
{
points.RemoveAt(points.Count - 1);
}
return(new Content.Annotation(annotation, PolyCurve.ByPoints(points, false)));
}
protected override (Curve boundary, List <Curve> holes) CreateBaseCurves()
{
Curve boundary = null;
if (UsesDepth)
{
var points = new[]
{
Point.ByCoordinates(0, 0),
Point.ByCoordinates(Width, 0),
Point.ByCoordinates(Width, Depth),
Point.ByCoordinates(Depth, Depth),
Point.ByCoordinates(Depth, Length),
Point.ByCoordinates(0, Length)
};
boundary = PolyCurve.ByPoints(points, connectLastToFirst: true);
points.ForEach(p => p.Dispose());
}
else
{
// L is too chunky - make a box.
boundary = Rectangle.ByWidthLength(BaseCenter, Width, Length);
}
return(boundary, default);
}
/// <summary>
/// A hyperbolic spiral is a transcendental plane curve also known as a reciprocal spiral, this the opposite of an Archimedean spiral and is a type of Cotes' spiral.
/// </summary>
/// <param name="angle">360 completes 1 circulation</param>
/// <param name="innerScale">Changing this will expand the inner circular part of the spiral</param>
/// <search>Hyperbolic,cotes,archimedes</search>
public static PolyCurve Hyperbolic(double angle = 3600, double innerScale = 100)
{
if (angle == 0.0)
{
throw new ArgumentException("The angle value can't be 0.", "angle");
}
if (angle < 0.0)
{
angle = angle * -1;
}
int numPts = 1000;
angle = degToRad(angle);
var pts = new List <Point>();
for (int i = 30; i < numPts; ++i)
{
double currAngle = (double)i / 1000.0 * angle;
double radius = innerScale / currAngle;
double xVal = radius * Math.Cos(currAngle);
double yVal = radius * Math.Sin(currAngle);
pts.Add(Point.ByCoordinates(xVal, yVal, 0));
}
return(PolyCurve.ByPoints(pts));
}
/// <exclude />
private Element ToHorizontalFloor(FloorType floorType, Level level)
{
Utils.Log(string.Format("MultiPoint.ToHorizontalFloor started...", ""));
try
{
if (!SessionVariables.ParametersCreated)
{
UtilsObjectsLocation.CheckParameters(DocumentManager.Instance.CurrentDBDocument);
}
PolyCurve outline = PolyCurve.ByPoints(this.ShapePoints.Points.Select(p => p.RevitPoint).ToList(), true);
outline = PolyCurve.ByJoinedCurves(outline.PullOntoPlane(Plane.XY()).Explode().Cast <Curve>().ToList());
var output = Floor.ByOutlineTypeAndLevel(outline, floorType, level);
output.SetParameterByName(ADSK_Parameters.Instance.MultiPoint.Name, SerializeJSON());
Utils.Log(string.Format("MultiPoint.ToHorizontalFloor completed.", ""));
return(output);
}
catch (Exception ex)
{
Utils.Log(string.Format("ERROR: MultiPoint.ToHorizontalFloor {0}", ex.Message));
throw ex;
}
}
public static Dictionary <string, object> DeconstructMesh(Mesh mesh)
{
List <List <uint> > faceIndexes = new List <List <uint> >();
IndexGroup[] ig = mesh.FaceIndices;
Point[] vertices = mesh.VertexPositions;
List <PolyCurve> edges = new List <PolyCurve>();
for (int i = 0; i < ig.Length; i++)
{
if (ig[i].Count == 3)
{
faceIndexes.Add(new List <uint> {
ig[i].A, ig[i].B, ig[i].C
});
}
if (ig[i].Count == 4)
{
faceIndexes.Add(new List <uint> {
ig[i].A, ig[i].B, ig[i].C, ig[i].D
});
}
}
for (int i = 0; i < faceIndexes.Count; i++)
{
for (int j = 0; j < faceIndexes[i].Count; j++)
{
if (faceIndexes[i].Count == 3)
{
Point[] verts = new Point[3];
verts[0] = vertices[(int)faceIndexes[i][0]];
verts[1] = vertices[(int)faceIndexes[i][1]];
verts[2] = vertices[(int)faceIndexes[i][2]];
edges.Add(PolyCurve.ByPoints(verts));
}
if (faceIndexes[i].Count == 4)
{
Point[] verts = new Point[4];
verts[0] = vertices[(int)faceIndexes[i][0]];
verts[1] = vertices[(int)faceIndexes[i][1]];
verts[2] = vertices[(int)faceIndexes[i][2]];
verts[3] = vertices[(int)faceIndexes[i][3]];
edges.Add(PolyCurve.ByPoints(verts));
}
}
}
return(new Dictionary <string, object>
{
{ "Vertices", mesh.VertexPositions },
{ "FaceIndexes", faceIndexes },
{ "Edges", edges },
{ "Normals", mesh.VertexNormals }
});
}
/// <summary>
/// Initializes a new instance of the <see cref="LandFeatureline"/> class.
/// </summary>
/// <param name="fl">The AeccLandFeatureline.</param>
/// <param name="style">The style name.</param>
internal LandFeatureline(AeccLandFeatureLine fl, string style = "")
{
if (fl == null)
{
return;
}
this._featureline = fl;
this._name = fl.Name;
this._minGrade = fl.MiniGrade;
this._minElevation = fl.MiniElevation;
this._maxElevation = fl.MaxElevation;
this._maxGrade = fl.MaxGrade;
this._style = style;
// Andrew Milford - Using reflection does not crash Dynamo
Type fltype = fl.GetType();
if (fltype != null)
{
try
{
dynamic coord = fltype.InvokeMember("GetPoints",
BindingFlags.InvokeMethod,
System.Type.DefaultBinder,
fl,
new object[] { AeccLandFeatureLinePointType.aeccLandFeatureLinePointPI });
IList <Point> points = new List <Point>();
for (int i = 0; i < coord.Length; i = i + 3)
{
double x = coord[i];
double y = coord[i + 1];
double z = coord[i + 2];
points.Add(Point.ByCoordinates(x, y, z));
}
if (points.Count > 1)
{
try
{
PolyCurve pc = PolyCurve.ByPoints(Point.PruneDuplicates(points));
this._polycurve = pc;
}
catch
{
// Not all Polycurves are branching
this._polycurve = null;
}
}
}
catch { }
}
}
/// <summary>
/// Gets a PolyCurve obtained by applying the offset and elevation displacement to each point of the Featureline PolyCurve.
/// </summary>
/// <param name="offset">The offset.</param>
/// <param name="elevation">The elevation.</param>
/// <returns></returns>
public PolyCurve GetPolyCurveByOffsetElevation(double offset, double elevation)
{
Utils.Log(string.Format("Featureline.GetPolyCurveByOffsetElevation started...", ""));
double startStation = this.Start; // soeStart[0];
double endStation = this.End; // soeEnd[0];
IList <double> stations = new List <double>()
{
startStation
};
foreach (double s in this.Baseline.Stations.Where(s => s >= startStation && s <= endStation))
{
stations.Add(s);
}
stations.Add(endStation);
Point p = Point.ByCoordinates(offset, 0, elevation);
CoordinateSystem cs = null;
IList <Point> points = new List <Point>();
foreach (double s in stations)
{
cs = this.CoordinateSystemByStation(s);
points.Add(p.Transform(cs) as Point);
}
points = Point.PruneDuplicates(points); // TODO this is slow
PolyCurve res = null;
if (points.Count > 1)
{
res = PolyCurve.ByPoints(points);
}
Utils.Log(string.Format("{0}", res));
if (p != null)
{
p.Dispose();
}
if (cs != null)
{
cs.Dispose();
}
Utils.Log(string.Format("Featureline.GetPolyCurveByOffsetElevation completed.", ""));
return(res);
}
/// <summary>
/// SpecklePolyline to DS Rectangle if closed , four points and sides parallel;
/// DS Polygon if closed or DS Polycurve otherwise
/// </summary>
/// <param name="polyline"></param>
/// <returns></returns>
public static Curve ToNative(this SpecklePolyline polyline)
{
var points = polyline.Value.ToPoints();
if (polyline.Closed)
{
return(PolyCurve.ByPoints(points).CloseWithLine().SetSpeckleProperties <PolyCurve>(polyline.Properties));
}
return(PolyCurve.ByPoints(points).SetSpeckleProperties <PolyCurve>(polyline.Properties));
}
/// <summary>
/// SpecklePolyline to DS Rectangle if closed , four points and sides parallel;
/// DS Polygon if closed or DS Polycurve otherwise
/// </summary>
/// <param name="polyline"></param>
/// <returns></returns>
public DS.Curve PolylineToNative(Polyline polyline)
{
var points = ArrayToPointList(polyline.value, polyline.units);
if (polyline.closed)
{
return(DS.PolyCurve.ByPoints(points).CloseWithLine()
.SetDynamoProperties <DS.PolyCurve>(GetDynamicMembersFromBase(polyline)));
}
return(PolyCurve.ByPoints(points).SetDynamoProperties <PolyCurve>(GetDynamicMembersFromBase(polyline)));
}
public override List <object> CreateGeometryObjects(List <Node> allNodes)
{
List <Point> points = new List <Point>();
for (int i = 0; i < NodeCount; i++)
{
points.Add(allNodes[NodeIndices[i]].Position.ToPoint());
}
return(new List <object> {
PolyCurve.ByPoints(points, Loop)
});
}
public override List <Geometry> GetGeometries(List <Node> allNodes)
{
List <Point> points = new List <Point>();
for (int i = 0; i < NodeCount; i++)
{
points.Add(allNodes[NodeIndices[i]].Position.ToPoint());
}
return(new List <Geometry> {
PolyCurve.ByPoints(points)
});
}
private Dictionary <string, object> TestCorridorInfo_Old(string code)
{
IList <string[]> corridorCodes = new List <string[]>();
IList <IList <Featureline> > corridorFeaturelines = new List <IList <Featureline> >();
foreach (Baseline bl in this.Baselines)
{
IList <Featureline> blFeaturelines = new List <Featureline>();
var b = bl._baseline;
foreach (AeccFeatureLines coll in b.MainBaselineFeatureLines.FeatureLinesCol)
{
foreach (AeccFeatureLine f in coll)
{
if (f.CodeName == code)
{
IList <Point> featureline = new List <Point>();
foreach (AeccFeatureLinePoint p in f.FeatureLinePoints)
{
Point point = Point.ByCoordinates(p.XYZ[0], p.XYZ[1], p.XYZ[2]);
featureline.Add(point);
}
featureline = Point.PruneDuplicates(featureline);
PolyCurve pc = PolyCurve.ByPoints(featureline);
var offset = bl.GetArrayStationOffsetElevationByPoint(pc.PointAtParameter(0.5))[1];
Featureline.SideType side = Featureline.SideType.Right;
if (offset < 0)
{
side = Featureline.SideType.Left;
}
blFeaturelines.Add(new Featureline(bl, pc, f.CodeName, side));
}
}
}
corridorFeaturelines.Add(blFeaturelines);
}
return(new Dictionary <string, object>()
{
{ "Featurelines", corridorFeaturelines }
});
}
public IList <LandFeatureline> GetLandFeaturelines(string xmlPath = "")
{
Utils.Log(string.Format("CivilDocument.GetLandFeaturelines started...", ""));
if (string.IsNullOrEmpty(xmlPath))
{
xmlPath = System.IO.Path.Combine(System.IO.Path.GetTempPath(), "LandFeatureLinesReport.xml");
}
bool result = this.SendCommand("-ExportLandFeatureLinesToXml\n");
IList <LandFeatureline> output = new List <LandFeatureline>();
if (result)
{
XmlDocument xmlDoc = new XmlDocument();
xmlDoc.Load(xmlPath);
AcadDatabase db = this._document as AcadDatabase;
AcadModelSpace ms = db.ModelSpace;
foreach (AcadEntity e in ms)
{
if (e.EntityName.ToLower().Contains("featureline"))
{
AeccLandFeatureLine f = e as AeccLandFeatureLine;
XmlElement fe = xmlDoc.GetElementsByTagName("FeatureLine").Cast <XmlElement>().First(x => x.Attributes["Name"].Value == f.Name);
IList <Point> points = new List <Point>();
foreach (XmlElement p in fe.GetElementsByTagName("Point"))
{
double x = Convert.ToDouble(p.Attributes["X"].Value);
double y = Convert.ToDouble(p.Attributes["Y"].Value);
double z = Convert.ToDouble(p.Attributes["Z"].Value);
points.Add(Point.ByCoordinates(x, y, z));
}
PolyCurve pc = PolyCurve.ByPoints(points);
string style = fe.Attributes["Style"].Value;
output.Add(new LandFeatureline(f, pc, style));
}
}
Utils.Log(string.Format("CivilDocument.GetLandFeaturelines completed.", ""));
}
return(output);
}
/// <summary>
/// Creates a Radiance Polygon.
/// </summary>
/// <param name="material">Material of the Polygon</param>
/// <param name="name">Name of the Polygon</param>
/// <param name="points">List of Points that define the Polygon (need to be planar).</param>
/// <returns></returns>
public static Objects.Polygon Polygon(string material, string name, List <Point> points)
{
//Check if points are planar
var pcurve = PolyCurve.ByPoints(points);
if (!pcurve.IsPlanar)
{
throw new ArgumentException("Points do not define a planar polygon!");
}
//Create new Polygon.
return(new Objects.Polygon(material, name, points));
}
public void BeforeTest()
{
surface = Surface.ByPatch(PolyCurve.ByPoints(new List <Point>
{
Point.ByCoordinates(0, 0, 0),
Point.ByCoordinates(27.129, 25.08, 0),
Point.ByCoordinates(10.318, 36.351, 0),
Point.ByCoordinates(-7.419, 16.573, 0)
}, true));
List <double> newRange = DSCore.Math.RemapRange(new List <double> {
0, 1, 2, 3, 4, 5, 6, 7, 8, 9
}, 0, 1) as List <double>;
uParams = newRange;
vParams = newRange;
}
/// <summary>
/// Gets list of shape polygons at a given record index.
/// </summary>
/// <param name="index">Record index for the shape</param>
/// <returns>List of PolyCurve</returns>
public IEnumerable <Curve> GetShapeAtRecord(int index)
{
return(ShapeData[index].Select(pts =>
{
var points = pts.Select(p => Point.ByCoordinates(p.X, p.Y, p.Z)).ToList();
var pts0 = points.Where((x, i) => i == 0 || !(x.IsAlmostEqualTo(points[i - 1]))).ToList();
var polygon = PolyCurve.ByPoints(pts0);
foreach (var item in points)
{
item.Dispose();
}
return polygon;
}));
}
/// <summary>
/// Converts the MultiPoint into a floor of the specified type.
/// </summary>
/// <param name="floorType">Type of the floor.</param>
/// <param name="level">The level.</param>
/// <param name="structural">if set to <c>true</c> [structural].</param>
/// <returns></returns>
public Element ToFloor(FloorType floorType, Level level, bool structural = true)
{
Utils.Log(string.Format("MultiPoint.ToFloor started...", ""));
try
{
if (!SessionVariables.ParametersCreated)
{
UtilsObjectsLocation.CheckParameters(DocumentManager.Instance.CurrentDBDocument);
}
PolyCurve outline = PolyCurve.ByPoints(this.ShapePoints.Points.Select(p => p.RevitPoint).ToList(), true);
if (null == outline)
{
System.Windows.Forms.MessageBox.Show("Outline is null");
}
Element output = null;
try
{
output = SlopedFloor.ByOutlineTypeAndLevel(outline, floorType, level, structural);
}
catch (Exception ex)
{
Utils.Log(string.Format("ERROR: MultiPoint.ToFloor {0}", ex.Message));
output = Floor.ByOutlineTypeAndLevel(outline, floorType, level);
}
output.SetParameterByName(ADSK_Parameters.Instance.MultiPoint.Name, this.SerializeJSON());
output.SetParameterByName(ADSK_Parameters.Instance.Update.Name, 1);
output.SetParameterByName(ADSK_Parameters.Instance.Delete.Name, 0);
Utils.Log(string.Format("MultiPoint.ToFloor completed.", ""));
return(output);
}
catch (Exception ex)
{
Utils.Log(string.Format("ERROR: MultiPoint.ToFloor {0}", ex.Message));
throw ex;
}
}
/// <summary>
/// Fermat's spiral (also known as a parabolic spiral) follows the equation r = +/- Theta^0.5
/// </summary>
/// <param name="angle">360 completes 1 circulation</param>
/// <search>golden,fibonacci</search>
public static PolyCurve Fermat(double angle = 3600)
{
if (angle == 0.0)
{
throw new ArgumentException("The angle value can't be 0.", "angle");
}
if (angle < 0.0)
{
angle = angle * -1;
}
int numPts = 1000;
angle = degToRad(angle);
var pts = new List <Point>();
for (int i = numPts - 1; i >= 0; --i)
{
double currAngle = (double)i / 1000.0 * angle;
double radius = Math.Sqrt(currAngle);
double xVal = radius * Math.Cos(currAngle);
double yVal = radius * Math.Sin(currAngle);
pts.Add(Point.ByCoordinates(-xVal, -yVal, 0));
}
for (int i = 1; i < numPts; ++i)
{
double currAngle = (double)i / 1000.0 * angle;
double radius = Math.Sqrt(currAngle);
double xVal = radius * Math.Cos(currAngle);
double yVal = radius * Math.Sin(currAngle);
pts.Add(Point.ByCoordinates(xVal, yVal, 0));
}
return(PolyCurve.ByPoints(pts));
}
/// <summary>
/// Gets a PolyCurve obtained by applying the offset and elevation displacement to each point of the Featureline PolyCurve.
/// </summary>
/// <param name="offset">The offset.</param>
/// <param name="elevation">The elevation.</param>
/// <returns></returns>
public PolyCurve GetPolyCurveByOffsetElevation(double offset, double elevation)
{
Utils.Log(string.Format("Featureline.GetPolyCurveByOffsetElevation started...", ""));
//double[] soeStart = this.GetStationOffsetElevationByPoint(this.Curve.StartPoint);
//double[] soeEnd = this.GetStationOffsetElevationByPoint(this.Curve.EndPoint);
double startStation = this.Start; // soeStart[0];
double endStation = this.End; // soeEnd[0];
IList <double> stations = new List <double>()
{
startStation
};
foreach (double s in this.Baseline.Stations.Where(s => s >= startStation && s <= endStation))
{
stations.Add(s);
}
stations.Add(endStation);
Point p = Point.ByCoordinates(offset, 0, elevation);
IList <Point> points = new List <Point>();
foreach (double s in stations)
{
points.Add(p.Transform(this.CoordinateSystemByStation(s)) as Point);
}
p.Dispose();
points = Point.PruneDuplicates(points);
Utils.Log(string.Format("Featureline.GetPolyCurveByOffsetElevation completed.", ""));
return(PolyCurve.ByPoints(points));
}
public static Content.Annotation ToPolyCurve(this PdfDictionary annotation, bool close)
{
PdfArray data = annotation.GetAsArray(PdfName.VERTICES);
if (data == null)
{
return(null);
}
List <Point> points = new List <Point>();
for (int j = 0; j < data.Size - 1; j = j + 2)
{
points.Add(Point.ByCoordinates(data[j].ToDouble(), data[j + 1].ToDouble()));
}
if (points.First().IsAlmostEqualTo(points.Last()))
{
points.RemoveAt(points.Count - 1);
}
return(new Content.Annotation(annotation, PolyCurve.ByPoints(points, close)));
}
/// <summary>
/// Gets the featurelines by code
/// </summary>
/// <param name="code">the Featurelines code.</param>
/// <returns></returns>
private IList <IList <Featureline> > GetFeaturelinesByCode_(string code) // 1.1.0
{
Utils.Log(string.Format("Baseline.GetFeaturelinesByCode({0}) Started...", code));
IList <IList <Featureline> > blFeaturelines = new List <IList <Featureline> >();
var b = this._baseline;
// 20190121 -- Start
AeccFeatureLines fs = null;
try
{
fs = b.MainBaselineFeatureLines.FeatureLinesCol.Item(code);
}
catch (Exception ex)
{
Utils.Log(string.Format("ERROR: {0}", ex.Message));
}
Dictionary <int, Dictionary <double, Point> > cFLs = new Dictionary <int, Dictionary <double, Point> >();
int i = 0;
if (fs != null)
{
Utils.Log(string.Format("Featurelines in region: {0}", fs.Count));
foreach (var fl in fs.Cast <AeccFeatureLine>())
{
Dictionary <double, Point> points = new Dictionary <double, Point>();
foreach (var pt in fl.FeatureLinePoints.Cast <AeccFeatureLinePoint>())
{
var p = pt.XYZ;
try
{
points.Add(Math.Round(pt.Station, 5), Point.ByCoordinates(p[0], p[1], p[2]));
}
catch (Exception ex)
{
Utils.Log(string.Format("ERROR: {0}", ex.Message));
}
}
cFLs.Add(i, points);
++i;
}
}
if (cFLs.Count > 0)
{
int regionIndex = 0;
foreach (AeccBaselineRegion region in b.BaselineRegions)
{
Utils.Log(string.Format("Processing region {0}...", regionIndex));
IList <Featureline> regFeaturelines = new List <Featureline>();
foreach (var k in cFLs.Keys)
{
IList <Point> points = new List <Point>();
var pts = cFLs[k];
if (pts.Keys.Count == 0)
{
continue;
}
foreach (double s in region.GetSortedStations())
{
var st = Math.Round(s, 5);
Point p = null;
if (pts.TryGetValue(st, out p))
{
points.Add(p);
}
}
points = Point.PruneDuplicates(points);
if (points.Count > 1)
{
PolyCurve pc = PolyCurve.ByPoints(points);
double offset = this.GetArrayStationOffsetElevationByPoint(pc.StartPoint)[1]; // 1.1.0
Featureline.SideType side = Featureline.SideType.Right;
if (offset < 0)
{
side = Featureline.SideType.Left;
}
regFeaturelines.Add(new Featureline(this, pc, code, side, regionIndex));
Utils.Log(string.Format("Featureline added", ""));
}
foreach (var pt in points)
{
pt.Dispose();
}
}
blFeaturelines.Add(regFeaturelines);
Utils.Log(string.Format("Region {0} completed.", regionIndex));
regionIndex++;
}
}
// 20190121 -- End
#region OLDCODE
//int regionIndex = 0;
//foreach (AeccBaselineRegion region in b.BaselineRegions)
//{
// IList<Featureline> regFeaturelines = new List<Featureline>();
// foreach (AeccFeatureLines coll in b.MainBaselineFeatureLines.FeatureLinesCol.Cast<AeccFeatureLines>().Where(fl => fl.FeatureLineCodeInfo.CodeName == code)) // 1.1.0
// {
// foreach (AeccFeatureLine f in coll.Cast<AeccFeatureLine>().Where(x => x.CodeName == code)) // maybe redundant?
// {
// double start = f.FeatureLinePoints.Item(0).Station; // 1.1.0
// double end = f.FeatureLinePoints.Item(f.FeatureLinePoints.Count - 1).Station; // 1.1.0
// bool reverse = start < end ? false : true; // 1.1.0
// IList<Point> points = new List<Point>();
// foreach (AeccFeatureLinePoint p in f.FeatureLinePoints)
// {
// Point point = Point.ByCoordinates(p.XYZ[0], p.XYZ[1], p.XYZ[2]);
// double s = Math.Round(p.Station, 5); // 1.1.0
// if (s >= region.StartStation || Math.Abs(s - region.StartStation) < 0.001)
// {
// if (s <= region.EndStation || Math.Abs(s - region.EndStation) < 0.001)
// {
// points.Add(point);
// }
// }
// }
// points = Point.PruneDuplicates(points);
// if (points.Count > 1)
// {
// PolyCurve pc = PolyCurve.ByPoints(points);
// if (reverse) // 1.1.0
// {
// pc = pc.Reverse() as PolyCurve;
// }
// double offset = this.GetArrayStationOffsetElevationByPoint(pc.StartPoint)[1]; // 1.1.0
// Featureline.SideType side = Featureline.SideType.Right;
// if (offset < 0)
// {
// side = Featureline.SideType.Left;
// }
// regFeaturelines.Add(new Featureline(this, pc, f.CodeName, side, regionIndex));
// }
// }
// }
// blFeaturelines.Add(regFeaturelines);
// regionIndex++;
//}
#endregion
Utils.Log(string.Format("Baseline.GetFeaturelinesByCode() Completed.", code));
return(blFeaturelines);
}
/// <summary>
/// Gets the featurelines by code and station
/// </summary>
/// <param name="code">the Featurelines code.</param>
/// <param name="station">the station used to select the featurelines.</param>
/// <returns></returns>
public IList <Featureline> GetFeaturelinesByCodeStation(string code, double station) // 1.1.0
{
Utils.Log(string.Format("Baseline.GetFeaturelinesByCodeStation({0}, {1}) Started...", code, station));
IList <Featureline> blFeaturelines = new List <Featureline>();
var b = this._baseline;
// 20190122 -- Start
AeccFeatureLines fs = null;
try
{
fs = b.MainBaselineFeatureLines.FeatureLinesCol.Item(code);
}
catch (Exception ex)
{
Utils.Log(string.Format("ERROR 1: {0}", ex.Message));
}
if (fs != null)
{
AeccBaselineRegion reg = null;
int regionIndex = 0;
foreach (AeccBaselineRegion region in b.BaselineRegions)
{
if (region.StartStation < station && region.EndStation > station || Math.Abs(station - region.StartStation) < 0.001 || Math.Abs(station - region.EndStation) < 0.001)
{
reg = region;
break;
}
++regionIndex;
}
if (reg != null)
{
foreach (var fl in fs.Cast <AeccFeatureLine>())
{
var pts = new List <Point>();
foreach (var pt in fl.FeatureLinePoints.Cast <AeccFeatureLinePoint>())
{
if (reg.StartStation < Math.Round(pt.Station, 5) && reg.EndStation > Math.Round(pt.Station, 5) ||
Math.Abs(Math.Round(pt.Station, 5) - reg.StartStation) < 0.001 ||
Math.Abs(Math.Round(pt.Station, 5) - reg.EndStation) < 0.001)
{
var p = pt.XYZ;
//try
//{
// pts.Add(Point.ByCoordinates(p[0], p[1], p[2]));
//}
//catch { }
try
{
pts.Add(Point.ByCoordinates(p[0], p[1], p[2]));
}
catch (Exception ex)
{
// 'System.Collections.Generic.IList<Autodesk.DesignScript.Geometry.Point>' does not contain a definition for 'Add'
Utils.Log(string.Format("ERROR 2: {0}", ex.Message));
}
}
}
var points = Point.PruneDuplicates(pts);
if (points.Count() > 1)
{
PolyCurve pc = PolyCurve.ByPoints(points);
double offset = this.GetArrayStationOffsetElevationByPoint(pc.StartPoint)[1]; // 1.1.0
Featureline.SideType side = Featureline.SideType.Right;
if (offset < 0)
{
side = Featureline.SideType.Left;
}
blFeaturelines.Add(new Featureline(this, pc, code, side, regionIndex));
Utils.Log(string.Format("Featureline added", ""));
}
foreach (var pt in points)
{
pt.Dispose();
}
}
}
}
// 20190122 -- End
#region OLD CODE
//int regionIndex = 0;
//foreach (AeccBaselineRegion region in b.BaselineRegions)
//{
// if (region.StartStation < station && region.EndStation > station || Math.Abs(station - region.StartStation) < 0.001 || Math.Abs(station - region.EndStation) < 0.001) // 1.1.0
// {
// foreach (AeccFeatureLines coll in b.MainBaselineFeatureLines.FeatureLinesCol.Cast<AeccFeatureLines>().Where(fl => fl.FeatureLineCodeInfo.CodeName == code)) // 1.1.0
// {
// foreach (AeccFeatureLine f in coll.Cast<AeccFeatureLine>().Where(x => x.CodeName == code)) // maybe redundant?
// {
// double start = f.FeatureLinePoints.Item(0).Station; // 1.1.0
// double end = f.FeatureLinePoints.Item(f.FeatureLinePoints.Count - 1).Station; // 1.1.0
// bool reverse = start < end ? false : true; // 1.1.0
// IList<Point> points = new List<Point>();
// foreach (AeccFeatureLinePoint p in f.FeatureLinePoints)
// {
// Point point = Point.ByCoordinates(p.XYZ[0], p.XYZ[1], p.XYZ[2]);
// double s = Math.Round(p.Station, 3); // 1.1.0
// if (s >= region.StartStation || Math.Abs(s - region.StartStation) < 0.001)
// {
// if (s <= region.EndStation || Math.Abs(s - region.EndStation) < 0.001)
// {
// points.Add(point);
// }
// }
// }
// points = Point.PruneDuplicates(points);
// if (points.Count > 1)
// {
// PolyCurve pc = PolyCurve.ByPoints(points);
// if (reverse) // 1.1.0
// {
// pc = pc.Reverse() as PolyCurve;
// }
// double offset = this.GetArrayStationOffsetElevationByPoint(pc.StartPoint)[1]; // 1.1.0
// Featureline.SideType side = Featureline.SideType.Right;
// if (offset < 0)
// {
// side = Featureline.SideType.Left;
// }
// blFeaturelines.Add(new Featureline(this, pc, f.CodeName, side, regionIndex));
// }
// }
// }
// }
// regionIndex++;
//}
#endregion
Utils.Log(string.Format("Baseline.GetFeaturelinesByCodeStation() Completed.", code));
return(blFeaturelines);
}
/// <summary>
/// Returns a collection of Featurelines in the Baseline for the given code organized by regions.
/// </summary>
/// <param name="code">The code of the Featurelines.</param>
/// <returns></returns>
private IList <IList <Featureline> > GetFeaturelinesFromXML(string code)
{
Utils.Log(string.Format("Baseline.GetFeaturelinesFromXML started ({0})...", code));
IList <IList <Featureline> > blFeaturelines = new List <IList <Featureline> >();
PolyCurve pc = null;
double side = 0;
int ri = -1;
Point lastPoint = null;
string xmlPath = Path.Combine(Environment.GetEnvironmentVariable("TMP", EnvironmentVariableTarget.User), string.Format("CorridorFeatureLines_{0}.xml", this._corridor.Name)); // Revit 2020 changed the path to the temp at a session level
Utils.Log(xmlPath);
if (!this._corridor._corridorFeaturelinesXMLExported)
{
this._baseline.Alignment.Document.SendCommand(string.Format("-ExportCorridorFeatureLinesToXml\n{0}\n", this._baseline.Corridor.Handle));
DateTime start = DateTime.Now;
while (true)
{
if (File.Exists(xmlPath))
{
if (File.GetLastWriteTime(xmlPath) > start)
{
start = File.GetLastWriteTime(xmlPath);
}
else
{
break;
}
}
}
this._corridor._corridorFeaturelinesXMLExported = true;
}
Utils.Log("XML acquired.");
if (File.Exists(xmlPath))
{
IList <Featureline> output = new List <Featureline>();
XmlDocument xmlDoc = new XmlDocument();
xmlDoc.Load(xmlPath);
foreach (XmlElement be in xmlDoc.GetElementsByTagName("Baseline")
.Cast <XmlElement>()
.Where(x => Convert.ToInt32(x.Attributes["Index"].Value) == this.Index && x.ParentNode.ParentNode.Attributes["Name"].Value == this.CorridorName))
{
try
{
foreach (XmlElement fe in be.GetElementsByTagName("FeatureLine").Cast <XmlElement>().Where(x => x.Attributes["Code"].Value == code))
{
try
{
IList <Point> points = new List <Point>();
double isBreak = 0;
int lastRi = -1;
foreach (XmlElement p in fe.GetElementsByTagName("Point").Cast <XmlElement>().OrderBy(e => Convert.ToDouble(e.Attributes["Station"].Value)))
{
try
{
double x = 0;
double y = 0;
double z = 0;
double b = 0;
double station = Convert.ToDouble(p.Attributes["Station"].Value);
try
{
x = Convert.ToDouble(p.Attributes["X"].Value);
}
catch (Exception ex)
{
Utils.Log(string.Format("ERROR: {0} X {1}", station, ex.Message));
}
try
{
y = Convert.ToDouble(p.Attributes["Y"].Value);
}
catch (Exception ex)
{
Utils.Log(string.Format("ERROR: {0} Y {1}", station, ex.Message));
}
try
{
z = Convert.ToDouble(p.Attributes["Z"].Value); // if Z is NaN because there is no profile associated in that station
}
catch (Exception ex)
{
Utils.Log(string.Format("ERROR: {0} Z {1}", station, ex.Message));
}
try
{
b = Convert.ToDouble(p.Attributes["IsBreak"].Value);
}
catch (Exception ex)
{
Utils.Log(string.Format("ERROR: {0} IsBreak {1}", station, ex.Message));
}
try
{
ri = Convert.ToInt32(p.Attributes["RegionIndex"].Value);
}
catch (Exception ex)
{
Utils.Log(string.Format("ERROR: {0} RegionIndex {1}", station, ex.Message));
}
isBreak += b;
if (ri - lastRi > 1 || b == 1)
{
Utils.Log(string.Format("Region change isBreak: {0}", b));
if (b == 1)
{
lastRi = ri;
if (points.Count > 0)
{
points.Add(Point.ByCoordinates(x, y, z));
}
}
else
{
lastRi = ri - 1;
}
if (points.Count > 0)
{
points = Point.PruneDuplicates(points).ToList();
}
if (points.Count > 1)
{
Utils.Log(string.Format("Points: {0}", points.Count));
pc = PolyCurve.ByPoints(points);
// int reg = this.GetBaselineRegionIndexByStation(station);
try
{
side = Convert.ToDouble(fe.Attributes["Side"].Value);
}
catch (Exception ex)
{
Utils.Log(string.Format("ERROR: Baseline.GetFeaturelinesFromXML Side {0}", ex.Message));
side = 1;
}
output.Add(new Featureline(this, pc, code, side < 0 ? Featureline.SideType.Left : Featureline.SideType.Right, lastRi));
lastPoint = points.Last();
points = new List <Point>();
if (b == 0)
{
points.Add(lastPoint);
}
//if (isBreak == 1)
//{
// isBreak = 0;
//}
}
//else
//{
// if (isBreak == 1)
// {
// isBreak = 0;
// }
//}
}
if (b != 1)
{
points.Add(Point.ByCoordinates(x, y, z));
}
// 20191005 -- START
//if (isBreak == 1)
//{
// Utils.Log("Break Point.");
// isBreak = 0;
// points = Point.PruneDuplicates(points);
// if (points.Count > 1)
// {
// Utils.Log(string.Format("Points: {0}", points.Count));
// pc = PolyCurve.ByPoints(points);
// //try
// //{
// // ri = Convert.ToInt32(fe.Attributes["RegionIndex"].Value);
// //}
// //catch (Exception ex)
// //{
// // Utils.Log(string.Format("ERROR: Baseline.GetFeaturelinesFromXML RegionIndex {0}", ex.Message));
// // ri = -1;
// //}
// try
// {
// side = Convert.ToDouble(fe.Attributes["Side"].Value);
// }
// catch (Exception ex)
// {
// Utils.Log(string.Format("ERROR: Baseline.GetFeaturelinesFromXML Side {0}", ex.Message));
// side = 1;
// }
// output.Add(new Featureline(this, pc, code, side < 0 ? Featureline.SideType.Left : Featureline.SideType.Right, ri));
// }
// points = new List<Point>();
//}
// 20191005 - END
}
catch (Exception ex)
{
Utils.Log(string.Format("ERROR: Baseline.GetFeaturelinesFromXML point failed {0} {1}", Convert.ToDouble(p.Attributes["Station"].Value), ex.Message));
}
}
if (isBreak == 0 && points.Count > 0)
{
points = Point.PruneDuplicates(points).ToList();
if (points.Count > 1)
{
Utils.Log(string.Format("Points: {0}", points.Count));
pc = PolyCurve.ByPoints(points);
try
{
//ri = Convert.ToInt32(fe.Attributes["RegionIndex"].Value);
ri = this.GetBaselineRegionIndexByStation(Convert.ToDouble(this.GetArrayStationOffsetElevationByPoint(points[points.Count / 2])[0]));
}
catch (Exception ex)
{
Utils.Log(string.Format("ERROR: Baseline.GetFeaturelinesFromXML RegionIndex {0}", ex.Message));
ri = -1;
}
try
{
side = Convert.ToDouble(fe.Attributes["Side"].Value);
}
catch (Exception ex)
{
Utils.Log(string.Format("ERROR: Baseline.GetFeaturelinesFromXML Side {0}", ex.Message));
side = 1;
}
output.Add(new Featureline(this, pc, code, side < 0 ? Featureline.SideType.Left : Featureline.SideType.Right, ri));
}
}
}
catch (Exception ex)
{
Utils.Log(string.Format("ERROR: Baseline.GetFeaturelinesFromXML Featureline failed {0}", ex.Message));
}
}
}
catch (Exception ex)
{
Utils.Log(string.Format("ERROR: Baseline.GetFeaturelinesFromXML failed {0}", ex.Message));
}
}
blFeaturelines = output.OrderBy(f => f.BaselineRegionIndex).GroupBy(f => f.BaselineRegionIndex).Cast <IList <Featureline> >().ToList();
}
else
{
Utils.Log("ERROR: Failed to locate CorridorFeatureLines.xml in the Temp folder.");
}
Utils.Log(string.Format("Baseline.GetFeaturelinesFromXML completed.", ""));
return(blFeaturelines);
}
public static Autodesk.DesignScript.Geometry.PolyCurve ToProtoType(this Autodesk.Revit.DB.PolyLine geom)
{
return(PolyCurve.ByPoints(geom.GetCoordinates().Select(x => Autodesk.DesignScript.Geometry.Point.ByCoordinates(x.X, x.Y, x.Z)).ToArray()));
}
protected override (Curve boundary, List <Curve> holes) CreateBaseCurves()
{
Curve boundary = null;
Point[] points;
if (IsCurved)
{
var holes = new List <Curve>();
var boundaryCurves = new List <Curve>();
var arcHeight = Math.Min(Length, Width / 2);
using (Plane arcCenter = Plane.ByOriginNormal(
Point.ByCoordinates(Width / 2, arcHeight),
Vector.ZAxis()))
{
boundaryCurves.Add(EllipseArc.ByPlaneRadiiAngles(arcCenter, Width / 2, arcHeight, 180, 180));
if (UsesDepth)
{
if (arcHeight < Length)
{
// Top of U has straight parts.
points = new[]
{
Point.ByCoordinates(Width, arcHeight),
Point.ByCoordinates(Width, Length),
Point.ByCoordinates(Width - Depth, Length),
Point.ByCoordinates(Width - Depth, arcHeight)
};
boundaryCurves.Add(PolyCurve.ByPoints(points));
points.ForEach(p => p.Dispose());
}
else
{
points = new[]
{
Point.ByCoordinates(Width, Length),
Point.ByCoordinates(Width - Depth, Length)
};
// Top of U has no straight parts.
boundaryCurves.Add(Line.ByStartPointEndPoint(points[0], points[1]));
points.ForEach(p => p.Dispose());
}
boundaryCurves.Add(EllipseArc.ByPlaneRadiiAngles(arcCenter, (Width / 2) - Depth, arcHeight - Depth, 0, -180));
if (arcHeight < Length)
{
// Top of U has straight parts.
points = new[]
{
Point.ByCoordinates(Depth, arcHeight),
Point.ByCoordinates(Depth, Length),
Point.ByCoordinates(0, Length),
Point.ByCoordinates(0, arcHeight)
};
boundaryCurves.Add(PolyCurve.ByPoints(points));
points.ForEach(p => p.Dispose());
}
else
{
// Top of U has no straight parts.
points = new[]
{
Point.ByCoordinates(Depth, Length),
Point.ByCoordinates(0, Length)
};
boundaryCurves.Add(Line.ByStartPointEndPoint(points[0], points[1]));
points.ForEach(p => p.Dispose());
}
}
else
{
// U has no interior.
if (arcHeight < Length)
{
points = new[]
{
Point.ByCoordinates(Width, arcHeight),
Point.ByCoordinates(Width, Length),
Point.ByCoordinates(0, Length),
Point.ByCoordinates(0, arcHeight)
};
boundaryCurves.Add(PolyCurve.ByPoints(points));
points.ForEach(p => p.Dispose());
}
else
{
points = new[]
{
Point.ByCoordinates(Width, Length),
Point.ByCoordinates(0, Length)
};
boundaryCurves.Add(Line.ByStartPointEndPoint(points[0], points[1]));
points.ForEach(p => p.Dispose());
}
}
}
boundary = PolyCurve.ByJoinedCurves(boundaryCurves);
}
else
{
// Straight U
if (UsesDepth)
{
points = new[]
{
Point.ByCoordinates(0, 0),
Point.ByCoordinates(Width, 0),
Point.ByCoordinates(Width, Length),
Point.ByCoordinates(Width - Depth, Length),
Point.ByCoordinates(Width - Depth, Depth),
Point.ByCoordinates(Depth, Depth),
Point.ByCoordinates(Depth, Length),
Point.ByCoordinates(0, Length)
};
boundary = PolyCurve.ByPoints(points, connectLastToFirst: true);
points.ForEach(p => p.Dispose());
}
else
{
// Solid straight U (rectangle)
points = new[]
{
Point.ByCoordinates(0, 0),
Point.ByCoordinates(Width, 0),
Point.ByCoordinates(Width, Length),
Point.ByCoordinates(0, Length)
};
boundary = PolyCurve.ByPoints(points, connectLastToFirst: true);
points.ForEach(p => p.Dispose());
}
}
return(boundary, default);
}
