public static Surface2D <T> Build(List <Vector3> Points, double meshSize)
{
var boundingBox = BoundingBoxBuilder.FromPtArray(Points.ToArray());
var surface = new Surface2D <T>(boundingBox, meshSize);
return(surface);
}
public void Drawing_CreateBoundingBox_0Points()
{
var doubles = new double[] { };
var points = VA.Drawing.Point.FromDoubles(doubles);
var bb = BoundingBoxBuilder.FromPoints(points);
Assert.IsFalse(bb.HasValue);
}
public static BoundingBox BuildBoundingBox(List <CylData> dataSetList)
{
var bblist = new List <BoundingBox>();
foreach (CylData set in dataSetList)
{
bblist.Add(set.BoundingBox);
}
return(BoundingBoxBuilder.Union(bblist.ToArray()));
}
public static VisioAutomation.Geometry.Rectangle GetBoundingBox(IEnumerable <ShapeXFormData> xfrms)
{
var bb = BoundingBoxBuilder.FromRectangles(xfrms.Select(x => x.GetRectangle()));
if (!bb.HasValue)
{
throw new System.ArgumentException("Could not calculate bounding box");
}
return(bb.Value);
}
private void getExtents()
{
List <Vector3> points = new List <Vector3>();
foreach (SurfacePoint sp in this)
{
points.Add(sp.Position);
}
_boundingBox = BoundingBoxBuilder.FromPtArray(points.ToArray());
}
void getBoundingBox()
{
var points = new List <Vector3>();
foreach (Triangle tri in this)
{
points.AddRange(tri.Vertices);
}
boundingBox = BoundingBoxBuilder.FromPtArray(points.ToArray());
}
public void Drawing_CreateBoundingBox_4Points()
{
var doubles = new[] { 0.0, 0.0, 1.0, -2.0 };
var points = VA.Drawing.Point.FromDoubles(doubles);
var bb = BoundingBoxBuilder.FromPoints(points);
Assert.IsTrue(bb.HasValue);
Assert.AreEqual(0, bb.Value.Left);
Assert.AreEqual(0, bb.Value.Top);
Assert.AreEqual(1, bb.Value.Right);
Assert.AreEqual(-2, bb.Value.Bottom);
}
public void BoundingBoxB_buildfromPts_returnsCorrectVals()
{
Vector3[] ptArray = new Vector3[3];
ptArray[0] = new Vector3(-1, -2, -3);
ptArray[1] = new Vector3(4, -4, 4);
ptArray[2] = new Vector3(1, 2, 3);
BoundingBox ext = BoundingBoxBuilder.FromPtArray(ptArray);
Assert.AreEqual(4d, ext.Max.X);
Assert.AreEqual(-4d, ext.Min.Y);
Assert.AreEqual(4d, ext.Max.Z);
}
public BoundingBox getBoundingBox(ToolPath5Axis inputPath)
{
var pointList = new List <Vector3>();
foreach (PathEntity5Axis ent in inputPath)
{
pointList.Add(new Vector3(ent.Position.X, ent.Position.Y, ent.Position.Z));
}
BoundingBox ext = BoundingBoxBuilder.FromPtArray(pointList.ToArray());
return(ext);
}
double getMinDepth(ModelPathEntity mpe, double searchRadius)
{
List <AbmachPoint> jetIntersectList = surface.GetPointsInsideBox(BoundingBoxBuilder.GetSearchBox(mpe.PositionAsVector3, searchRadius));
double minDepth = 1e16;
foreach (AbmachPoint pt in jetIntersectList)
{
double depth = getPointDepth(pt);
if (depth < minDepth)
{
minDepth = depth;
}
}
return(minDepth);
}
public void BoundingBoxB_union_returnsCorrectVals()
{
Vector3[] ptArray = new Vector3[3];
ptArray[0] = new Vector3(-1, -2, -3);
ptArray[1] = new Vector3(4, -4, 4);
ptArray[2] = new Vector3(1, 2, 3);
Vector3[] ptArray2 = new Vector3[3];
ptArray2[0] = new Vector3(4, 5, -3);
ptArray2[1] = new Vector3(4, -4, 6);
ptArray2[2] = new Vector3(-8, 2, 3);
BoundingBox ext1 = BoundingBoxBuilder.FromPtArray(ptArray);
BoundingBox ext2 = BoundingBoxBuilder.FromPtArray(ptArray2);
BoundingBox ext = BoundingBoxBuilder.Union(ext1, ext2);
Assert.AreEqual(-8d, ext.Min.X);
Assert.AreEqual(4d, ext.Max.X);
Assert.AreEqual(5d, ext.Max.Y);
}
public Drawing.Rectangle GetBoundingBoxOfTree()
{
if (this.Root.ChildCount < 1)
{
throw new System.InvalidOperationException("There are no Nodes in the tree");
}
var nodes = this.Nodes.ToList();
var bb = BoundingBoxBuilder.FromRectangles(nodes.Select(n => n.Rect));
if (!bb.HasValue)
{
throw new System.InvalidOperationException("Internal Error: Could not compute bounding box");
}
else
{
return(bb.Value);
}
}
double getAveDepth(ModelPathEntity mpe, double searchRadius)
{
double depth = 0;
List <AbmachPoint> jetIntersectList = surface.GetPointsInsideBox(BoundingBoxBuilder.GetSearchBox(mpe.PositionAsVector3, searchRadius));
int pointCount = 0;
foreach (AbmachPoint pt in jetIntersectList)
{
if (pt.JetHit)
{
depth += getPointDepth(pt);
pointCount++;
}
}
depth = pointCount > 0 ? depth / pointCount : 0;
return(depth);
}
static public Octree <T> Build(List <Vector3> points, double minPointSpacing)
{
try
{
BoundingBox boundingBox = BoundingBoxBuilder.CubeFromPtArray(points);
Octree <T> octree = new Octree <T>(boundingBox, minPointSpacing);
// int index = 0;
foreach (Vector3 pt in points)
{
T octpt = new T();
//octpt.Index = index++;
octpt.Position = pt;
octree.Insert(octpt);
}
return(octree);
}
catch (Exception)
{
throw;
}
}
public void triangle_asPointGrid_gridOK()
{
var v0 = new Vector3(2, 1, 0);
var v1 = new Vector3(4, 2, 0);
var v2 = new Vector3(2, 4, 0);
Triangle tri = new Triangle(v0, v1, v2);
List <IVector3> points = tri.AsPointGrid(.1);
bool areContained = false;
foreach (IVector3 pt in points)
{
areContained = tri.Contains(pt);
Assert.IsTrue(areContained);
}
IBoundingBox bb = BoundingBoxBuilder.FromPtArray(points.ToArray());
Assert.AreEqual(4.0, bb.Max.X, .001);
Assert.AreEqual(1.0, bb.Min.Y, .001);
Assert.AreEqual(4.0, bb.Max.Y, .001);
Assert.IsTrue(areContained);
}
static public QuadTree <T> Build(List <Vector3> points, double minPointSpacing)
{
try
{
BoundingBox boundingBox = BoundingBoxBuilder.CubeFromPtArray(points);
QuadTree <T> tree = new QuadTree <T>(boundingBox, minPointSpacing);
foreach (Vector3 pt in points)
{
T octpt = new T
{
Position = pt
};
tree.Insert(octpt);
}
return(tree);
}
catch (Exception)
{
throw;
}
}
public void Octree_getpointsInboxfromSearchBox_pointsOK()
{
List <Vector3> vectorList = new List <Vector3>();
for (int i = 0; i <= 100; i++)
{
for (int j = 0; j <= 100; j++)
{
vectorList.Add(new Vector3(i * .1, j * .1, 1.0));
}
}
Octree <SurfacePoint> Octree = OctreeBuilder <SurfacePoint> .Build(vectorList, .1);
Vector3 searchPoint = new Vector3(5, 6, 3);
Vector3 direction = new Vector3(0, 0, 1);
Ray ray = new Ray(searchPoint, direction);
double searchRadius = Octree.MeshSize * 3;
var searchBox = BoundingBoxBuilder.GetSearchCylinder(Octree.BoundingBox, searchPoint, direction, searchRadius);
List <SurfacePoint> points = Octree.GetPointsInsideBox(searchBox);
Assert.AreNotEqual(0, points.Count);
}
BoundingBox getBoundingBox(List <DwgEntity> entities)
{
BoundingBox ext = new BoundingBox();
var boundingBoxList = new List <BoundingBox>();
foreach (DwgEntity entity in entities)
{
if (entity is Line)
{
Line line = entity as Line;
boundingBoxList.Add(line.BoundingBox());
}
if (entity is Arc)
{
Arc arc = entity as Arc;
boundingBoxList.Add(arc.BoundingBox());
}
}
ext = BoundingBoxBuilder.Union(boundingBoxList.ToArray());
return(ext);
}
public void triangle_asPointGrid_countOK()
{
var v0 = new Vector3(5, 0, 0);
var v1 = new Vector3(0, 5, 0);
var v2 = new Vector3(5, 5, 0);
Triangle tri = new Triangle(v0, v1, v2);
List <Vector3> points = tri.AsPointGrid(.1);
bool areContained = false;
foreach (Vector3 pt in points)
{
areContained = tri.Contains(pt);
Assert.IsTrue(areContained);
}
BoundingBox bb = BoundingBoxBuilder.FromPtArray(points.ToArray());
Assert.AreEqual(1300, points.Count, 40);
Assert.AreEqual(5.0, bb.Max.X, .001);
Assert.AreEqual(0.0, bb.Min.Y, .001);
Assert.AreEqual(5.0, bb.Max.Y, .001);
Assert.IsTrue(areContained);
}
static public Octree <T> Build(List <T> Points, double minPointSpacing)
{
try
{
List <Vector3> points = new List <Vector3>();
foreach (T pt in Points)
{
points.Add(pt.Position);
}
BoundingBox boundingBox = BoundingBoxBuilder.CubeFromPtArray(points);
Octree <T> octree = new Octree <T>(boundingBox, minPointSpacing);
octree.Insert(Points);
return(octree);
}
catch (Exception)
{
throw;
}
}
private void getBoundingBox()
{
List <BoundingBox> extentList = new List <BoundingBox>();
foreach (DwgEntity entity in entities)
{
if (entity is Line)
{
Line line = entity as Line;
extentList.Add(line.BoundingBox());
}
if (entity is Arc)
{
Arc arc = entity as Arc;
extentList.Add(arc.BoundingBox());
}
if (entity is Vector3)
{
Vector3 pt = entity as Vector3;
extentList.Add(pt.BoundingBox());
}
}
boundingBox = BoundingBoxBuilder.Union(extentList.ToArray());
}
public IBoundingBox BoundingBox()
{
var bbList = new List <IBoundingBox>();
foreach (DwgEntity entity in Entities)
{
if (entity is Line3)
{
Line3 line = entity as Line3;
bbList.Add(line.BoundingBox());
}
if (entity is Arc)
{
Arc arc = entity as Arc;
bbList.Add(arc.BoundingBox());
}
if (entity is Vector3)
{
Vector3 pt = entity as Vector3;
bbList.Add(pt.BoundingBox());
}
}
return(BoundingBoxBuilder.Union(bbList));
}
//public List<T> GetKNearestPoints(Vector3 searchPoint, int searchQty)
//{
// try
// {
// int resultCount = 0;
// var results = new List<T>();
// if (searchQty == 0)
// {
// return results;
// }
// double initSearchWidth = minSeparation * Math.Min(searchQty, 3);
// double searchSize = 1;
// double maxSearchDim = 2 * Math.Max((searchPoint - _boundingBox.Min).Length, (_boundingBox.Max - searchPoint).Length);
// Vector3 searchHalfDimension = new Vector3(initSearchWidth, initSearchWidth, initSearchWidth);
// // search and expand search box until point count is >= k
// do
// {
// var box = new BoundingBox(searchPoint - searchHalfDimension, searchPoint + searchHalfDimension);
// results = new List<T>();
// getPointsInBox(box, ref results);
// resultCount = results.Count;
// if (resultCount == 0)
// {
// searchSize *= 2;
// }
// else
// {
// searchSize *= ((double)searchQty / (double)resultCount);
// }
// searchHalfDimension = new Vector3(searchSize * initSearchWidth, searchSize * initSearchWidth, searchSize * initSearchWidth);
// } while (resultCount < searchQty && searchHalfDimension.Length < maxSearchDim);
// double[] distances = new double[resultCount];
// T[] resultArray = results.ToArray();
// // find closest k points to search point and add to output
// if (resultCount > searchQty)
// {
// for (int i = 0; i < resultCount; i++)
// {
// distances[i] = searchPoint.Distance2To(resultArray[i].Position);
// }
// Array.Sort(distances, resultArray);
// return resultArray.ToList();
// }
// else
// {
// return results;
// }
// }
// catch (Exception)
// {
// throw;
// }
//}
public IntersectionRecord GetIntersection(Ray ray)
{
try
{
var searchBox = BoundingBoxBuilder.GetSearchCylinder(_boundingBox, ray.Origin, ray.Direction, minSeparation * 3);
List <T> points = GetPointsInsideBox(searchBox);
Vector3 intPt = new Vector3();
double denom = (ray.Direction - ray.Origin).Length;
Vector3 rayEnd = ray.Direction - ray.Origin;
if (denom > 0 && points.Count == 1)
{
return(new IntersectionRecord(points[0].Position, true));
}
if (denom > 0 && points.Count > 1)
{
double[] distArr = new double[points.Count];
Vector3[] ptArr = new Vector3[points.Count];
int i = 0;
foreach (T pt in points)
{
distArr[i] = GeomUtilities.RayPointDistance(ray, pt.Position);
ptArr[i] = pt.Position;
i++;
}
Array.Sort(distArr, ptArr);
return(new IntersectionRecord(ptArr[0], true));
}
return(new IntersectionRecord());
}
catch (Exception)
{
throw;
}
}
public void DrawPath(IEnumerable<PathOperation> ops, Pen pen = null, BaseBrush brush = null)
{
var bb = new BoundingBoxBuilder ();
var s = new D2D1.PathGeometry (factories.D2DFactory);
var figureDepth = 0;
using (var sink = s.Open ()) {
foreach (var op in ops) {
if (op is MoveTo) {
while (figureDepth > 0) {
sink.EndFigure (D2D1.FigureEnd.Open);
figureDepth--;
}
var mt = ((MoveTo)op);
sink.BeginFigure (Conversions.ToVector2 (mt.Start), D2D1.FigureBegin.Filled);
figureDepth++;
bb.Add (mt.Start);
}
else if (op is LineTo) {
var lt = ((LineTo)op);
sink.AddLine (lt.Start.ToVector2());
sink.AddLine (lt.End.ToVector2());
bb.Add (lt.Start);
bb.Add (lt.End);
}
else if (op is ArcTo) {
var ar = ((ArcTo)op);
// TODO: Direct2D Arcs
//sink.AddArc (new D2D1.ArcSegment {
// Size = Conversions.ToSize2F (ar.Radius),
// Point = Conversions.ToVector2 (ar.Point),
// SweepDirection = ar.SweepClockwise ? D2D1.SweepDirection.Clockwise : D2D1.SweepDirection.CounterClockwise,
//});
sink.AddLine (Conversions.ToVector2 (ar.Point));
bb.Add (ar.Point);
}
else if (op is CurveTo) {
var ct = ((CurveTo)op);
sink.AddBezier (new D2D1.BezierSegment {
Point1 = Conversions.ToVector2 (ct.FirstControlPoint),
Point2 = Conversions.ToVector2 (ct.SecondControlPoint),
Point3 = Conversions.ToVector2 (ct.End),
});
bb.Add(ct.FirstControlPoint);
bb.Add(ct.SecondControlPoint);
bb.Add(ct.End);
}
else if (op is ClosePath) {
sink.EndFigure (D2D1.FigureEnd.Closed);
figureDepth--;
}
else {
// TODO: More path operations
}
}
while (figureDepth > 0) {
sink.EndFigure (D2D1.FigureEnd.Open);
figureDepth--;
}
sink.Close ();
}
var p = GetBrush (pen);
var b = GetBrush (bb.BoundingBox, brush);
if (b != null) {
renderTarget.FillGeometry (s, b);
}
if (p != null) {
renderTarget.DrawGeometry (s, p, (float)pen.Width, GetStrokeStyle (pen));
}
}
public void DrawPath(IEnumerable<PathOperation> ops, Pen pen = null, BaseBrush baseBrush = null)
{
if (pen == null && baseBrush == null)
return;
DrawElement (() => {
var bb = new BoundingBoxBuilder ();
var lines = new List<CGPoint>();
foreach (var op in ops) {
var moveTo = op as MoveTo;
if (moveTo != null) {
var start = moveTo.Start;
var end = moveTo.End;
context.MoveTo ((nfloat)start.X, (nfloat)start.Y);
context.MoveTo ((nfloat)end.X, (nfloat)end.Y);
bb.Add (start);
bb.Add (end);
continue;
}
var lt = op as LineTo;
if (lt != null) {
var start = lt.Start;
var end = lt.End;
context.AddLineToPoint((float)start.X, (float)start.Y);
context.AddLineToPoint((float)end.X, (float)end.Y);
bb.Add (start);
bb.Add (end);
continue;
}
var at = op as ArcTo;
if (at != null) {
var p = at.Point;
var pp = Conversions.GetPoint (context.GetPathCurrentPoint ());
Point c1, c2;
at.GetCircles (pp, out c1, out c2);
context.AddLineToPoint ((nfloat)p.X, (nfloat)p.Y);
bb.Add (p);
continue;
}
var curveTo = op as CurveTo;
if (curveTo != null) {
var end = curveTo.End;
var control1 = curveTo.FirstControlPoint;
var control2 = curveTo.SecondControlPoint;
context.AddCurveToPoint ((nfloat)control1.X, (nfloat)control1.Y, (nfloat)control2.X, (nfloat)control2.Y, (nfloat)end.X, (nfloat)end.Y);
bb.Add (control1);
bb.Add (control2);
bb.Add (end);
continue;
}
var cp = op as ClosePath;
if (cp != null) {
context.ClosePath ();
continue;
}
throw new NotSupportedException ("Path Op " + op);
}
return bb.BoundingBox;
}, pen, baseBrush);
}
public void DrawPath(IEnumerable <PathOperation> ops, Pen pen = null, BaseBrush baseBrush = null)
{
using (var path = new GraphicsPath())
{
var bb = new BoundingBoxBuilder();
var position = Point.Zero;
foreach (var op in ops)
{
var start = op as StartFigure;
if (start != null)
{
path.StartFigure();
continue;
}
var moveTo = op as MoveTo;
if (moveTo != null)
{
path.StartFigure();
continue;
}
var lineTo = op as LineTo;
if (lineTo != null)
{
var p = lineTo.Start;
path.AddLine(Conversions.GetPointF(lineTo.Start), Conversions.GetPointF(lineTo.End));
position = p;
bb.Add(p);
continue;
}
var arcTo = op as ArcTo;
if (arcTo != null)
{
var p = arcTo.Point;
path.AddLine(Conversions.GetPointF(position), Conversions.GetPointF(p));
position = p;
bb.Add(p);
continue;
}
var curveTo = op as CurveTo;
if (curveTo != null)
{
path.AddBezier(Conversions.GetPointF(curveTo.Start), Conversions.GetPointF(curveTo.FirstControlPoint),
Conversions.GetPointF(curveTo.SecondControlPoint), Conversions.GetPointF(curveTo.End));
bb.Add(curveTo.Start);
bb.Add(curveTo.FirstControlPoint);
bb.Add(curveTo.SecondControlPoint);
bb.Add(curveTo.End);
continue;
}
var closePath = op as ClosePath;
if (closePath != null)
{
path.CloseFigure();
continue;
}
throw new NotSupportedException("Path Op " + op);
}
var frame = bb.BoundingBox;
if (baseBrush != null)
{
graphics.FillPath(baseBrush.GetBrush(frame), path);
}
if (pen != null)
{
var r = Conversions.GetRectangleF(frame);
graphics.DrawPath(pen.GetPen(), path);
}
}
}
public void DrawPath(IEnumerable <PathOperation> ops, Pen pen = null, BaseBrush brush = null)
{
using (var path = new Path())
{
var bb = new BoundingBoxBuilder();
foreach (var op in ops)
{
var moveTo = op as MoveTo;
if (moveTo != null)
{
var start = moveTo.Start;
var end = moveTo.End;
path.MoveTo((float)start.X, (float)start.Y);
bb.Add(start);
bb.Add(end);
continue;
}
var lineTo = op as LineTo;
if (lineTo != null)
{
var start = lineTo.Start;
var end = lineTo.End;
path.LineTo((float)start.X, (float)start.Y);
path.LineTo((float)end.X, (float)end.Y);
bb.Add(start);
bb.Add(end);
continue;
}
var at = op as ArcTo;
if (at != null)
{
var p = at.Point;
path.LineTo((float)p.X, (float)p.Y);
bb.Add(p);
continue;
}
var curveTo = op as CurveTo;
if (curveTo != null)
{
var end = curveTo.End;
var firstControlPoint = curveTo.FirstControlPoint;
var secondControlPoint = curveTo.SecondControlPoint;
path.CubicTo((float)firstControlPoint.X, (float)firstControlPoint.Y, (float)secondControlPoint.X,
(float)secondControlPoint.Y, (float)end.X, (float)end.Y);
bb.Add(firstControlPoint);
bb.Add(secondControlPoint);
bb.Add(end);
continue;
}
var cp = op as ClosePath;
if (cp != null)
{
path.Close();
continue;
}
throw new NotSupportedException("Path Op " + op);
}
var frame = bb.BoundingBox;
if (brush != null)
{
var solidBrush = brush as SolidBrush;
if (solidBrush != null)
{
path.SetFillType(GetPathFillType(((SolidBrush)brush).FillMode));
}
var brushPaint = GetBrushPaint(brush, frame);
graphics.DrawPath(path, brushPaint);
}
if (pen != null)
{
var penPaint = GetPenPaint(pen);
graphics.DrawPath(path, penPaint);
}
}
}
public void DrawPath(IEnumerable <PathOperation> ops, Pen pen = null, BaseBrush brush = null)
{
var bb = new BoundingBoxBuilder();
var s = new D2D1.PathGeometry(factories.D2DFactory);
var figureDepth = 0;
using (var sink = s.Open()) {
foreach (var op in ops)
{
if (op is MoveTo)
{
while (figureDepth > 0)
{
sink.EndFigure(D2D1.FigureEnd.Open);
figureDepth--;
}
var mt = ((MoveTo)op);
sink.BeginFigure(Conversions.ToVector2(mt.Start), D2D1.FigureBegin.Filled);
figureDepth++;
bb.Add(mt.Start);
}
else if (op is LineTo)
{
var lt = ((LineTo)op);
sink.AddLine(lt.Start.ToVector2());
sink.AddLine(lt.End.ToVector2());
bb.Add(lt.Start);
bb.Add(lt.End);
}
else if (op is ArcTo)
{
var ar = ((ArcTo)op);
// TODO: Direct2D Arcs
//sink.AddArc (new D2D1.ArcSegment {
// Size = Conversions.ToSize2F (ar.Radius),
// Point = Conversions.ToVector2 (ar.Point),
// SweepDirection = ar.SweepClockwise ? D2D1.SweepDirection.Clockwise : D2D1.SweepDirection.CounterClockwise,
//});
sink.AddLine(Conversions.ToVector2(ar.Point));
bb.Add(ar.Point);
}
else if (op is CurveTo)
{
var ct = ((CurveTo)op);
sink.AddBezier(new D2D1.BezierSegment {
Point1 = Conversions.ToVector2(ct.FirstControlPoint),
Point2 = Conversions.ToVector2(ct.SecondControlPoint),
Point3 = Conversions.ToVector2(ct.End),
});
bb.Add(ct.FirstControlPoint);
bb.Add(ct.SecondControlPoint);
bb.Add(ct.End);
}
else if (op is ClosePath)
{
sink.EndFigure(D2D1.FigureEnd.Closed);
figureDepth--;
}
else
{
// TODO: More path operations
}
}
while (figureDepth > 0)
{
sink.EndFigure(D2D1.FigureEnd.Open);
figureDepth--;
}
sink.Close();
}
var p = GetBrush(pen);
var b = GetBrush(bb.BoundingBox, brush);
if (b != null)
{
renderTarget.FillGeometry(s, b);
}
if (p != null)
{
renderTarget.DrawGeometry(s, p, (float)pen.Width, GetStrokeStyle(pen));
}
}
public void Run(CancellationToken ct, IProgress <int> progress)
{
try
{
double searchRadius = jetRadius + surface.MeshSize;
int pcount = path.Count * runInfo.Runs * runInfo.Iterations;
int count = 0;
List <string> pointlist = new List <string>();
pointlist.Add("run,Nx,Ny,Nz,x,z,pointradius,jetfactor,incidentangle,slopefactor");
double spFactor = spacingFactor();
double testJetRadius = jetRadius + surface.MeshSize;
for (int iteration = 1; iteration <= runInfo.Iterations; iteration++)
{
runInfo.CurrentIteration = iteration;
for (int run = 1; run <= runInfo.Runs; run++)
{
runInfo.CurrentRun = run;
int pathCount = 0;
foreach (ModelPathEntity mpe in path)
{
if (!ct.IsCancellationRequested)
{
double feedFactor = currentRemovalRate.DepthPerPass * spFactor * feedrateFactor(mpe.Feedrate.Value, currentRemovalRate);
pathCount++;
if (mpe.JetOn && feedFactor != 0)
{
BoundingBox searchBox = BoundingBoxBuilder.GetSearchCylinder(surface.BoundingBox, mpe.PositionAsVector3, mpe.JetVector, searchRadius);
List <AbmachPoint> jetIntersectList = surface.GetPointsInsideBox(searchBox);
Octree <AbmachPoint> localSurface = OctreeBuilder <AbmachPoint> .Build(jetIntersectList, surface.MeshSize);// OctreeBuilder<AbmachPoint>.Build(jetIntersectList, searchBox, surface.MeshSize);
var newPts = new List <AbmachPoint>();
var mpeV = new Vector3(mpe.Position.X, mpe.Position.Y, 0);
var jetRay = new Ray(mpe.PositionAsVector3, mpe.JetVector);
foreach (AbmachPoint jetPt in localSurface.GetAllPoints())
{
if (jetPt != null)
{
//var jetV = new Vector3(jetPt.Position.X, jetPt.Position.Y, 0);
//double pointRadius = jetV.DistanceTo(mpeV);
double pointRadius = GeomUtilities.RayPointDistance(jetRay, jetPt.Position);
if (pointRadius <= testJetRadius)
{
double jFactor = jetFactor(pointRadius);
if (jFactor > 0)
{
Vector3 localNormal = new Vector3(0, 0, 1); // localSurface.GetNormalAt(jetPt.Position);
if (localNormal.Length == 0)
{
localNormal = new Vector3(mpe.JetVector);
}
double angle = incidentAngle(mpe.JetVector, localNormal);
double slFactor = slopeFactor(angle);
//debug
if (jetPt.Position.X > 0.006 && jetPt.Position.X < .1 && jetPt.Position.Y > .072 && jetPt.Position.Y < .102)
{
pointlist.Add(run.ToString() + "," + jetPt.Position.X.ToString("f5") + "," + jetPt.Position.Y.ToString("f5") + "," + jetPt.Position.Z.ToString("f5") + "," + pointRadius.ToString("f5") + "," + jFactor.ToString("F5") + "," + angle.ToString("F5") + "," + slFactor.ToString("F5"));
}
//debug
Vector3 materialRemoved = (feedFactor * slFactor * jFactor) * mpe.JetVector;
Vector3 newPosition = jetPt.Position - materialRemoved;
jetPt.Position = newPosition;
jetPt.Normal = localNormal;
jetPt.OriginalPosition = jetPt.OriginalPosition;
jetPt.JetHit = true;
newPts.Add(jetPt);
}
}
else
{
newPts.Add(jetPt);
}
} //end foreach jetPt
}
surface.Insert(newPts);
}//endif jeton
}
progress.Report(100 * ++count / pcount);
}//next path entity
if (runInfo.RunType == ModelRunType.NewMRR)
{
currentRemovalRate = newRemovalRate(path, runInfo, currentRemovalRate, depthInfo);
}
} //next run
if (runInfo.RunType == ModelRunType.NewFeedrates && runInfo.CurrentIteration < runInfo.Iterations)
{
path = newFeedrates(path, depthInfo);
resetSurface();
}
}//next iteration
FileIOLib.FileIO.Save(pointlist, "slopefactor.csv");
}
catch (Exception)
{
throw;
}
}
private void getBoundingBox()
{
boundingBox = BoundingBoxBuilder.FromPtArray(new Vector3[] { Vert0, Vert1, Vert2 });
}
public void DrawPath(IEnumerable <PathOperation> ops, Pen pen = null, BaseBrush baseBrush = null)
{
if (pen == null && baseBrush == null)
{
return;
}
DrawElement(() => {
var bb = new BoundingBoxBuilder();
var lines = new List <CGPoint>();
foreach (var op in ops)
{
var moveTo = op as MoveTo;
if (moveTo != null)
{
var start = moveTo.Start;
var end = moveTo.End;
context.MoveTo((nfloat)start.X, (nfloat)start.Y);
context.MoveTo((nfloat)end.X, (nfloat)end.Y);
bb.Add(start);
bb.Add(end);
continue;
}
var lt = op as LineTo;
if (lt != null)
{
var start = lt.Start;
var end = lt.End;
context.AddLineToPoint((float)start.X, (float)start.Y);
context.AddLineToPoint((float)end.X, (float)end.Y);
bb.Add(start);
bb.Add(end);
continue;
}
var at = op as ArcTo;
if (at != null)
{
var p = at.Point;
var pp = Conversions.GetPoint(context.GetPathCurrentPoint());
Point c1, c2;
at.GetCircles(pp, out c1, out c2);
context.AddLineToPoint((nfloat)p.X, (nfloat)p.Y);
bb.Add(p);
continue;
}
var curveTo = op as CurveTo;
if (curveTo != null)
{
var end = curveTo.End;
var control1 = curveTo.FirstControlPoint;
var control2 = curveTo.SecondControlPoint;
context.AddCurveToPoint((nfloat)control1.X, (nfloat)control1.Y, (nfloat)control2.X, (nfloat)control2.Y, (nfloat)end.X, (nfloat)end.Y);
bb.Add(control1);
bb.Add(control2);
bb.Add(end);
continue;
}
var cp = op as ClosePath;
if (cp != null)
{
context.ClosePath();
continue;
}
throw new NotSupportedException("Path Op " + op);
}
return(bb.BoundingBox);
}, pen, baseBrush);
}
public void DrawPath(IEnumerable<PathOperation> ops, Pen pen = null, BaseBrush brush = null)
{
using (var path = new Path())
{
var bb = new BoundingBoxBuilder();
foreach (var op in ops)
{
var moveTo = op as MoveTo;
if (moveTo != null)
{
var start = moveTo.Start;
var end = moveTo.End;
path.MoveTo((float) start.X, (float) start.Y);
bb.Add(start);
bb.Add(end);
continue;
}
var lineTo = op as LineTo;
if (lineTo != null)
{
var start = lineTo.Start;
var end = lineTo.End;
path.LineTo((float) start.X, (float) start.Y);
path.LineTo((float) end.X, (float) end.Y);
bb.Add(start);
bb.Add(end);
continue;
}
var at = op as ArcTo;
if (at != null)
{
var p = at.Point;
path.LineTo((float) p.X, (float) p.Y);
bb.Add(p);
continue;
}
var curveTo = op as CurveTo;
if (curveTo != null)
{
var end = curveTo.End;
var firstControlPoint = curveTo.FirstControlPoint;
var secondControlPoint = curveTo.SecondControlPoint;
path.CubicTo((float) firstControlPoint.X, (float) firstControlPoint.Y, (float) secondControlPoint.X,
(float) secondControlPoint.Y, (float) end.X, (float) end.Y);
bb.Add(firstControlPoint);
bb.Add(secondControlPoint);
bb.Add(end);
continue;
}
var cp = op as ClosePath;
if (cp != null)
{
path.Close();
continue;
}
throw new NotSupportedException("Path Op " + op);
}
var frame = bb.BoundingBox;
if (brush != null)
{
var solidBrush = brush as SolidBrush;
if (solidBrush != null)
{
path.SetFillType(GetPathFillType(((SolidBrush)brush).FillMode));
}
var brushPaint = GetBrushPaint(brush, frame);
graphics.DrawPath(path, brushPaint);
}
if (pen != null)
{
var penPaint = GetPenPaint(pen);
graphics.DrawPath(path, penPaint);
}
}
}
async ValueTask <GeoJSONObject> ReadGeometryCore(NpgsqlReadBuffer buf, bool async, BoundingBoxBuilder boundingBox)
{
await buf.Ensure(SizeOfHeader, async);
var littleEndian = buf.ReadByte() > 0;
var type = (EwkbGeometryType)buf.ReadUInt32(littleEndian);
GeoJSONObject geometry;
NamedCRS crs = null;
if (HasSrid(type))
{
await buf.Ensure(4, async);
crs = GetCrs(buf.ReadInt32(littleEndian));
}
switch (type & EwkbGeometryType.BaseType)
{
case EwkbGeometryType.Point:
{
await buf.Ensure(SizeOfPoint(type), async);
var position = ReadPosition(buf, type, littleEndian);
boundingBox?.Accumulate(position);
geometry = new Point(position);
break;
}
case EwkbGeometryType.LineString:
{
await buf.Ensure(SizeOfLength, async);
var coordinates = new Position[buf.ReadInt32(littleEndian)];
for (var i = 0; i < coordinates.Length; ++i)
{
await buf.Ensure(SizeOfPoint(type), async);
var position = ReadPosition(buf, type, littleEndian);
boundingBox?.Accumulate(position);
coordinates[i] = position;
}
geometry = new LineString(coordinates);
break;
}
case EwkbGeometryType.Polygon:
{
await buf.Ensure(SizeOfLength, async);
var lines = new LineString[buf.ReadInt32(littleEndian)];
for (var i = 0; i < lines.Length; ++i)
{
var coordinates = new Position[buf.ReadInt32(littleEndian)];
for (var j = 0; j < coordinates.Length; ++j)
{
await buf.Ensure(SizeOfPoint(type), async);
var position = ReadPosition(buf, type, littleEndian);
boundingBox?.Accumulate(position);
coordinates[j] = position;
}
lines[i] = new LineString(coordinates);
}
geometry = new Polygon(lines);
break;
}
case EwkbGeometryType.MultiPoint:
{
await buf.Ensure(SizeOfLength, async);
var points = new Point[buf.ReadInt32(littleEndian)];
for (var i = 0; i < points.Length; ++i)
{
await buf.Ensure(SizeOfHeader + SizeOfPoint(type), async);
await buf.Skip(SizeOfHeader, async);
var position = ReadPosition(buf, type, littleEndian);
boundingBox?.Accumulate(position);
points[i] = new Point(position);
}
geometry = new MultiPoint(points);
break;
}
case EwkbGeometryType.MultiLineString:
{
await buf.Ensure(SizeOfLength, async);
var lines = new LineString[buf.ReadInt32(littleEndian)];
for (var i = 0; i < lines.Length; ++i)
{
await buf.Ensure(SizeOfHeaderWithLength, async);
await buf.Skip(SizeOfHeader, async);
var coordinates = new Position[buf.ReadInt32(littleEndian)];
for (var j = 0; j < coordinates.Length; ++j)
{
await buf.Ensure(SizeOfPoint(type), async);
var position = ReadPosition(buf, type, littleEndian);
boundingBox?.Accumulate(position);
coordinates[j] = position;
}
lines[i] = new LineString(coordinates);
}
geometry = new MultiLineString(lines);
break;
}
case EwkbGeometryType.MultiPolygon:
{
await buf.Ensure(SizeOfLength, async);
var polygons = new Polygon[buf.ReadInt32(littleEndian)];
for (var i = 0; i < polygons.Length; ++i)
{
await buf.Ensure(SizeOfHeaderWithLength, async);
await buf.Skip(SizeOfHeader, async);
var lines = new LineString[buf.ReadInt32(littleEndian)];
for (var j = 0; j < lines.Length; ++j)
{
var coordinates = new Position[buf.ReadInt32(littleEndian)];
for (var k = 0; k < coordinates.Length; ++k)
{
await buf.Ensure(SizeOfPoint(type), async);
var position = ReadPosition(buf, type, littleEndian);
boundingBox?.Accumulate(position);
coordinates[k] = position;
}
lines[j] = new LineString(coordinates);
}
polygons[i] = new Polygon(lines);
}
geometry = new MultiPolygon(polygons);
break;
}
case EwkbGeometryType.GeometryCollection:
{
await buf.Ensure(SizeOfLength, async);
var elements = new IGeometryObject[buf.ReadInt32(littleEndian)];
for (var i = 0; i < elements.Length; ++i)
{
elements[i] = (IGeometryObject) await ReadGeometryCore(buf, async, boundingBox);
}
geometry = new GeometryCollection(elements);
break;
}
default:
throw new NpgsqlSafeReadException(UnknownPostGisType());
}
geometry.CRS = crs;
return(geometry);
}
