public MarkGeometryCubicBezier(MarkGeometryPoint startPointIn, MarkGeometryPoint endPointIn, MarkGeometryPoint controlPoint_1In, MarkGeometryPoint controlPoint_2In)
: base()
{
StartPoint = startPointIn;
EndPoint = endPointIn;
ControlPoint_1 = controlPoint_1In;
ControlPoint_2 = controlPoint_2In;
Update();
}
public MarkGeometryRectangle(MarkGeometryPoint centrePoint, double width, double height)
: base()
{
CentrePoint = centrePoint;
Width = width;
Height = height;
GenerateView();
Update();
}
public MarkGeometryArc(MarkGeometryPoint center, double radius, double endAngle)
: base()
{
Radius = radius;
StartAngle = 0;
EndAngle = endAngle;
CentrePoint = center;
Update();
}
public MarkGeometryEllipse(Ellipse ellipse)
: base()
{
CentrePoint = new MarkGeometryPoint(ellipse.Center);
StartAngle = ellipse.StartAngle;
EndAngle = ellipse.EndAngle;
MinorAxis = ellipse.MajorAxis; // AKA the y-axis
MajorAxis = ellipse.MinorAxis; // AKA. the x-axis
Update();
}
public MarkGeometriesWrapper()
{
Points = new List <MarkGeometryPoint>();
Lines = new List <MarkGeometryLine>();
Arcs = new List <MarkGeometryArc>();
Circles = new List <MarkGeometryCircle>();
Paths = new List <MarkGeometryPath>();
Origin = new MarkGeometryPoint();
Update();
}
/// <summary>
/// The copy constructor for this class.
/// </summary>
/// <param name="input"></param>
internal MarkGeometryPoint(MarkGeometryPoint input)
: base(input)
{
// force copy
X = input.X + 0.0;
Y = input.Y + 0.0;
Z = input.Z + 0.0;
Update();
}
/// <summary>
/// Create and arc from three points.
/// </summary>
/// <param name="centre">The centre of the arc.</param>
/// <param name="p1">The starting point</param>
/// <param name="p2">The end point</param>
public MarkGeometryArc(MarkGeometryPoint centre, MarkGeometryPoint p1, MarkGeometryPoint p2)
{
Radius = GeometricArithmeticModule.ABSMeasure(centre, p1);
StartAngle = GeometricArithmeticModule.CalculateAngle(centre, p1);
EndAngle = GeometricArithmeticModule.CalculateAngle(centre, p2);
CentrePoint = centre;
StartPoint = p1;
EndPoint = p2;
Update();
}
public MarkGeometryArc(MarkGeometryPoint center, double radius, double startAngle, double endAngle)
: base()
{
Radius = radius;
StartAngle = startAngle;
EndAngle = endAngle;
CentrePoint = center;
StartPoint = new MarkGeometryPoint();
EndPoint = new MarkGeometryPoint();
Update();
}
public MarkGeometryArc()
: base()
{
Radius = 0;
StartAngle = 0;
EndAngle = 0;
CentrePoint = new MarkGeometryPoint();
StartPoint = new MarkGeometryPoint();
EndPoint = new MarkGeometryPoint();
Update();
}
public void GenerateView()
{
double halfWidth = Width / 2.0;
double halfHeight = Height / 2.0;
TopLeftPoint = new MarkGeometryPoint(CentrePoint.X - halfWidth, CentrePoint.Y + halfHeight);
TopRightPoint = new MarkGeometryPoint(CentrePoint.X + halfWidth, CentrePoint.Y + halfHeight);
BottomLeftPoint = new MarkGeometryPoint(CentrePoint.X - halfWidth, CentrePoint.Y - halfHeight);
BottomRightPoint = new MarkGeometryPoint(CentrePoint.X + halfWidth, CentrePoint.Y - halfHeight);
IsClosed = true;
Points = new List <MarkGeometryPoint>()
{
TopLeftPoint, TopRightPoint, BottomRightPoint, BottomLeftPoint, (MarkGeometryPoint)TopLeftPoint.Clone()
};
}
/// <summary>
/// Add point to the end of the path
/// </summary>
/// <param name="point"></param>
/// <param name="deferUpdate"></param>
public void Append(MarkGeometryPoint point, bool deferUpdate = false)
{
if (
Points.Count > 0 &&
GeometricArithmeticModule.Compare(EndPoint, point, ClosureTolerance) == 0
)
{
return; // ignore existing points
}
Points.Add(point);
if (!deferUpdate)
{
Update();
}
}
public MarkGeometryPath(params MarkGeometryLine[] lines)
: base()
{
if (lines != null && lines.Length > 0)
{
Points.Add(lines[0].StartPoint);
for (int i = 0; i < lines.Length; i++)
{
Points.Add(lines[i].EndPoint);
}
}
// TODO : Calculate centroid
CentrePoint = new MarkGeometryPoint();
Update();
}
public override void ReadXml(XmlReader reader)
{
reader.Read();// Skip ahead to next node
base.ReadXml(reader);
StartPoint = new MarkGeometryPoint();
StartPoint.ReadXml(reader);
EndPoint = new MarkGeometryPoint();
EndPoint.ReadXml(reader);
ReferencePoint = new MarkGeometryPoint();
ReferencePoint.ReadXml(reader);
Update();
}
//public MarkGeometryPath(LwPolyline lwPolyline)
// : base()
//{
// foreach (var entity in lwPolyline.Explode())
// {
// if (entity is Line lineEntity)
// {
// Points.Add(new MarkGeometryPoint(lineEntity.StartPoint));
// Points.Add(new MarkGeometryPoint(lineEntity.EndPoint));
// }
// else if (entity is Arc arcEntity)
// {
// arcEntity.PolygonalVertexes
// }
// }
// Points.AddRange(
// lwPolyline.Vertexes.ConvertAll(v => new MarkGeometryPoint(v))
// );
// if (
// lwPolyline.IsClosed &&
// GeometricArithmeticModule.Compare(StartPoint, EndPoint, ClosureTolerance) != 0)
// {
// Points.Add((MarkGeometryPoint)StartPoint.Clone());
// }
// // TODO : Calculate centroid
// CentrePoint = new MarkGeometryPoint();
// Update();
//}
public MarkGeometryPath(Polyline polyline)
: base()
{
Points.AddRange(
polyline.Vertexes.Select(v => new MarkGeometryPoint(v.Position))
);
if (
polyline.IsClosed &&
GeometricArithmeticModule.Compare(StartPoint, EndPoint, ClosureTolerance) != 0)
{
Points.Add((MarkGeometryPoint)StartPoint.Clone());
}
// TODO : Calculate centroid
CentrePoint = new MarkGeometryPoint();
Update();
}
public MarkGeometryRectangle(MarkGeometryPoint pointA, MarkGeometryPoint pointB)
: base()
{
MarkGeometryRectangle rect = new MarkGeometryLine(pointA, pointB).Extents.Boundary;
Points.AddRange(rect.Points);
CentrePoint = rect.CentrePoint;
Width = rect.Width;
Height = rect.Height;
IsClosed = true;
double halfWidth = Width / 2.0;
double halfHeight = Height / 2.0;
TopLeftPoint = new MarkGeometryPoint(CentrePoint.X - halfWidth, CentrePoint.Y + halfHeight);
TopRightPoint = new MarkGeometryPoint(CentrePoint.X + halfWidth, CentrePoint.Y + halfHeight);
BottomLeftPoint = new MarkGeometryPoint(CentrePoint.X - halfWidth, CentrePoint.Y - halfHeight);
BottomRightPoint = new MarkGeometryPoint(CentrePoint.X + halfWidth, CentrePoint.Y - halfHeight);
Update();
}
/// <summary>
/// Adapted from CSharp's netdxf library.
/// </summary>
/// <param name="position">A double representing a position on the spline</param>
/// <returns>A point at the specified location on the Spline</returns>
public MarkGeometryPoint C(double position)
{
double denominatorSum = 0.0;
var _point = new MarkGeometryPoint();
for (int i = 0; i < ControlPoints.Count; i++)
{
// optional use n * controlPoint's weight - in this case it's 1.0
double n = N(i, Degree, position);
denominatorSum += n;
_point += n * ControlPoints[i];
}
// avoid possible divided by zero error, this should never happen
if (Math.Abs(denominatorSum) < double.Epsilon)
{
return(new MarkGeometryPoint());
}
return((1.0 / denominatorSum) * _point);
}
public override void ReadXml(XmlReader reader)
{
reader.Read();// Skip ahead to next node
ReadXmlBaseImpl(reader);
reader.ReadStartElement();
Width = double.Parse(reader.ReadElementString(nameof(Width)));
reader.Read();
Height = double.Parse(reader.ReadElementString(nameof(Height)));
Points = new List <MarkGeometryPoint>();
CentrePoint = new MarkGeometryPoint();
CentrePoint.ReadXml(reader);
reader.Read();
reader.ReadEndElement();
GenerateView();
Update();
}
/// <summary>
/// see: http://www.lee-mac.com/bulgeconversion.html
/// The curvature of a Polyline Arc segment is defined using a quantity known as bulge.
/// This unit measures the deviation of the curve from the straight line (chord) joining the two vertices of the segment.
/// It is defined as the ratio of the arc sagitta (versine) to half the length of
/// the chord between the two vertices; this ratio is equal to the tangent of a
/// quarter of the included arc angle between the two polyline vertices.
/// </summary>
/// <param name="startPoint"></param>
/// <param name="endPoint"></param>
/// <param name="bulge"></param>
public MarkGeometryArc(MarkGeometryPoint startPoint, MarkGeometryPoint endPoint, double bulge)
{
var d = GeometricArithmeticModule.ABSMeasure(startPoint, endPoint) / 2d;
var r = (d * ((Math.Pow(bulge, 2)) + 1)) / (2 * bulge);
var th = GeometricArithmeticModule.CalculateAngle(startPoint, endPoint) + Math.Acos(d / r);
Radius = Math.Abs(r);
CentrePoint = MarkGeometryPoint.FromPolar(startPoint, th, r);
if (bulge < 0)
{
StartAngle = GeometricArithmeticModule.CalculateAngle(CentrePoint, endPoint);
EndAngle = GeometricArithmeticModule.CalculateAngle(CentrePoint, startPoint);
}
else
{
StartAngle = GeometricArithmeticModule.CalculateAngle(CentrePoint, startPoint);
EndAngle = GeometricArithmeticModule.CalculateAngle(CentrePoint, endPoint);
}
Update();
}
public override void ReadXml(XmlReader reader)
{
reader.Read(); // Skip ahead to next node
base.ReadXml(reader);
IsClosed = bool.Parse(reader.GetAttribute(nameof(IsClosed)));
CentrePoint = new MarkGeometryPoint();
CentrePoint.ReadXml(reader);
Points = new List <MarkGeometryPoint>();
if (reader.MoveToContent() == XmlNodeType.Element && reader.LocalName == nameof(Points))
{
while (reader.MoveToContent() == XmlNodeType.Element)
{
var point = new MarkGeometryPoint();
point.ReadXml(reader);
Points.Add(point);
}
}
Update();
}
public override void SetExtents()
{
Extents.MinX = double.MaxValue;
Extents.MaxX = double.MinValue;
Extents.MinY = double.MaxValue;
Extents.MaxY = double.MinValue;
Extents.MinZ = double.MaxValue;
Extents.MaxZ = double.MinValue;
int[] ns =
{
Points.Count(),
Arcs.Count(),
Circles.Count(),
Lines.Count(),
Paths.Count()
};
int n = GeometricArithmeticModule.Max <int>(ns);
for (int i = 0; i < n; i++)
{
if (i < Points.Count())
{
Extents.MaxX = Math.Max(Extents.MaxX, Points[i].Extents.MaxX);
Extents.MaxY = Math.Max(Extents.MaxY, Points[i].Extents.MaxY);
Extents.MaxZ = Math.Max(Extents.MaxZ, Points[i].Extents.MaxZ);
Extents.MinX = Math.Min(Extents.MinX, Points[i].Extents.MinX);
Extents.MinY = Math.Min(Extents.MinY, Points[i].Extents.MinY);
Extents.MinZ = Math.Min(Extents.MinZ, Points[i].Extents.MinZ);
}
if (i < Arcs.Count())
{
Extents.MaxX = Math.Max(Extents.MaxX, Arcs[i].Extents.MaxX);
Extents.MaxY = Math.Max(Extents.MaxY, Arcs[i].Extents.MaxY);
Extents.MaxZ = Math.Max(Extents.MaxZ, Arcs[i].Extents.MaxZ);
Extents.MinX = Math.Min(Extents.MinX, Arcs[i].Extents.MinX);
Extents.MinY = Math.Min(Extents.MinY, Arcs[i].Extents.MinY);
Extents.MinZ = Math.Min(Extents.MinZ, Arcs[i].Extents.MinZ);
}
if (i < Circles.Count())
{
Extents.MaxX = Math.Max(Extents.MaxX, Circles[i].Extents.MaxX);
Extents.MaxY = Math.Max(Extents.MaxY, Circles[i].Extents.MaxY);
Extents.MaxZ = Math.Max(Extents.MaxZ, Circles[i].Extents.MaxZ);
Extents.MinX = Math.Min(Extents.MinX, Circles[i].Extents.MinX);
Extents.MinY = Math.Min(Extents.MinY, Circles[i].Extents.MinY);
Extents.MinZ = Math.Min(Extents.MinZ, Circles[i].Extents.MinZ);
}
if (i < Lines.Count())
{
Extents.MaxX = Math.Max(Extents.MaxX, Lines[i].Extents.MaxX);
Extents.MaxY = Math.Max(Extents.MaxY, Lines[i].Extents.MaxY);
Extents.MaxZ = Math.Max(Extents.MaxZ, Lines[i].Extents.MaxZ);
Extents.MinX = Math.Min(Extents.MinX, Lines[i].Extents.MinX);
Extents.MinY = Math.Min(Extents.MinY, Lines[i].Extents.MinY);
Extents.MinZ = Math.Min(Extents.MinZ, Lines[i].Extents.MinZ);
}
if (i < Paths.Count())
{
Extents.MaxX = Math.Max(Extents.MaxX, Paths[i].Extents.MaxX);
Extents.MaxY = Math.Max(Extents.MaxY, Paths[i].Extents.MaxY);
Extents.MaxZ = Math.Max(Extents.MaxZ, Paths[i].Extents.MaxZ);
Extents.MinX = Math.Min(Extents.MinX, Paths[i].Extents.MinX);
Extents.MinY = Math.Min(Extents.MinY, Paths[i].Extents.MinY);
Extents.MinZ = Math.Min(Extents.MinZ, Paths[i].Extents.MinZ);
}
}
GridWidth = Extents.MaxX - Extents.MinX;
GridHeight = Extents.MaxY - Extents.MinY;
GridDepth = Extents.MaxZ - Extents.MinZ;
Origin = new MarkGeometryPoint(
Extents.MinX + (0.5 * GridWidth),
Extents.MinY + (0.5 * GridHeight),
Extents.MinZ + (0.5 * GridDepth)
);
}
public MarkGeometryQuadraticBezier(MarkGeometryPoint startPointIn, MarkGeometryPoint endPointIn, MarkGeometryPoint controlPointIn)
: base()
{
StartPoint = startPointIn;
EndPoint = endPointIn;
ControlPoint = controlPointIn;
Update();
}
public void Add(MarkGeometryPoint points)
{
Points.Add(points);
Update();
}
