/// <summary>
/// Exports a string representation of polygons.
/// Can be uses to import it again.
/// </summary>
/// <returns>A multi-line string of a polypolygon points definitions.</returns>
public String ToExportString()
{
List <List <PolyPointDescriptor> > polys = CachedPolyPointList;
String exp = PolygonHelper.BuildExportString(polys);
return(exp);
}
/// <summary>
/// Updates this instance and his related Objects. Especially the cached poly polygon points
/// </summary>
virtual public void Update()
{
if (_updating)
{
return;
}
try
{
_updating = true;
if (IsValid())
{
OoShapeObserver.LockValidation = true;
try
{
CachedPolyPointList = PolygonHelper.GetPolyPoints(Shape.Shape);
IsClosed(false);
IsBezier(false);
}
finally
{
OoShapeObserver.LockValidation = false;
_updating = false;
}
}
else
{
CachedPolyPointList = null;
}
}
finally
{
_updating = false;
}
}
private void button9_Click(object sender, EventArgs e)
{
if (!(dataModel.SelectedItem is PolygonHelper ph2))
{
return;
}
var hull = DeepNest.getHull(ph2.TransformedNfp());
PolygonHelper ph = new PolygonHelper();
ph.Polygon = hull;
var box = ph.BoundingBox().Value;
PolygonHelper ph3 = new PolygonHelper();
ph3.Polygon = new NFP()
{
Points = new SvgPoint[] {
new SvgPoint(box.Left, box.Top),
new SvgPoint(box.Left, box.Bottom),
new SvgPoint(box.Right, box.Bottom),
new SvgPoint(box.Right, box.Top),
}
};
ph3.Name = "AABB";
dataModel.AddItem(ph3);
}
private void button10_Click(object sender, EventArgs e)
{
if (!(dataModel.SelectedItem is PolygonHelper ph2))
{
return;
}
var hull = DeepNest.getHull(new NFP()
{
Points = ph2.TransformedPoints().ToArray()
});
PolygonHelper ph = new PolygonHelper();
ph.Polygon = hull;
var mar = GeometryUtil.GetMinimumBox(hull.Points.Select(z => new Vector2d(z.X, z.Y)).ToArray());
PolygonHelper ph3 = new PolygonHelper();
ph3.Polygon = new NFP()
{
Points = mar.Select(z => new SvgPoint(z.X, z.Y)).ToArray()
};
ph3.Name = "minRect";
dataModel.AddItem(ph3);
}
private void button6_Click(object sender, EventArgs e)
{
List <PolygonHelper> ar1 = new List <PolygonHelper>();
for (int i = 0; i < dataModel.SelectedItems.Length; i++)
{
ar1.Add(dataModel.SelectedItems[i] as PolygonHelper);
}
if (ar1.Count != 2)
{
dataModel.ParentForm.StatusMessage("there are no 2 polygon selected", StatusMessageType.Warning); return;
}
PolyBool pb = new PolyBool();
//var poly1 = GetPolygon(ar1[0].TransformedPoints().ToArray());
//var poly2 = GetPolygon(ar1[1].TransformedPoints().ToArray());
var poly1 = ar1[0].GetPolygon();
var poly2 = ar1[1].GetPolygon();
var r = pb.intersect(poly1, poly2);
if (r.regions.Count == 0)
{
dataModel.ParentForm.StatusMessage("no intersections", StatusMessageType.Warning);
return;
}
var pnts = r.regions.ToArray()[0].ToArray();
PolygonHelper ph = new PolygonHelper();
ph.Polygon.Points = pnts.Select(z => new SvgPoint(z.x, z.y)).ToArray();
dataModel.AddItem(ph);
}
public void AreaOk3()
{
// a complicated snake
var points = new Point[]
{
new Point(-2, 3),
new Point(-5, 0),
new Point(-5.62, -4.69),
new Point(-2.86, -6.99),
new Point(1.94, -7.27),
new Point(4.38, -4.21),
new Point(5.44, -0.15),
new Point(3.52, -2.17),
new Point(2.64, -4.23),
new Point(0.36, -5.47),
new Point(-2.76, -4.73),
new Point(-3.42, -3.19),
new Point(-3.44, -0.83),
new Point(-0.06, -2.25),
new Point(-1.64, -3.53),
new Point(-2.28, -2.11),
new Point(-2.1, -4.31),
new Point(0.44, -3.67),
new Point(0.92, -0.21),
new Point(-2.08, 0.51)
};
var etalon = 45.83;
var(a, e) = PolygonHelper.Area(points);
Console.WriteLine($"Error:{e.ToString()}\r\nAnswer:{a.ToString(PrecisionPoly)}\r\nEtalon:{etalon.ToString(PrecisionPoly)}");
Assert.AreEqual(Errors.None, e);
Assert.AreEqual(etalon.ToString(PrecisionPoly), a.ToString(PrecisionPoly));
}
/// <summary>
/// Determines whether this Freeform is a closed one or an open one.
/// </summary>
/// <param name="cached">if set to <c>true</c> the previously cached result will be returned.</param>
/// <returns>
/// <c>true</c> if the Freeform is a closed one; otherwise, <c>false</c>.
/// </returns>
virtual public bool IsClosed(bool cached = true)
{
if (IsValid() && !cached)
{
_isClosed = PolygonHelper.IsClosedFreeForm(Shape.Shape);
}
return(_isClosed);
}
/// <summary>
/// Gets the polygon points.
/// </summary>
/// <returns>a warper for helping handling polygon points or <c>null</c> if this is not a shape that have polygon points.</returns>
virtual public OoPolygonPointsObserver GetPolygonPointsObserver()
{
if (_ppObs == null && PolygonHelper.IsFreeform(Shape))
{
_ppObs = new OoPolygonPointsObserver(this);
}
return(_ppObs);
}
private void dxfFromFileToolStripMenuItem_Click(object sender, EventArgs e)
{
OpenFileDialog ofd = new OpenFileDialog();
ofd.Filter = "dxf files (*.dxf)|*.dxf";
if (ofd.ShowDialog() != DialogResult.OK)
{
return;
}
var r = DxfParser.LoadDxf(ofd.FileName);
List <NFP> nfps = new List <NFP>();
foreach (var rr in r)
{
nfps.Add(new NFP()
{
Points = rr.Points.Select(z => new SvgPoint(z.X, z.Y)).ToArray()
});
}
for (int i = 0; i < nfps.Count; i++)
{
for (int j = 0; j < nfps.Count; j++)
{
if (i != j)
{
var d2 = nfps[i];
var d3 = nfps[j];
var f0 = d3.Points[0];
if (StaticHelpers.pnpoly(d2.Points.ToArray(), f0.X, f0.Y))
{
d3.Parent = d2;
if (!d2.Childrens.Contains(d3))
{
d2.Childrens.Add(d3);
}
}
}
}
}
List <HelperItem> ret = new List <HelperItem>();
foreach (var item in nfps)
{
if (item.Parent != null)
{
continue;
}
PolygonHelper phh = new PolygonHelper();
phh.Name = new FileInfo(ofd.FileName).Name;
ret.Add(phh);
phh.Polygon = item;
}
dataModel.AddItems(ret.ToArray());
}
private void button8_Click(object sender, EventArgs e)
{
List <PolygonHelper> phhs = new List <PolygonHelper>();
//if (!checkBox1.Checked)
{
if (dataModel.SelectedItems.Length < 2)
{
dataModel.ParentForm.StatusMessage("there are no 2 polygon selected", StatusMessageType.Warning); return;
}
foreach (var item in dataModel.SelectedItems)
{
phhs.Add(item as PolygonHelper);
}
}
// else
{
// phhs.Add((comboBox2.SelectedItem as ComboBoxItem).Tag as PolygonHelper);
// phhs.Add((comboBox3.SelectedItem as ComboBoxItem).Tag as PolygonHelper);
}
var ar1 = phhs.ToArray();
NFP p = new NFP();
NFP p2 = new NFP();
var jType = (JoinType)comboBox1.SelectedIndex;
double offset = double.Parse(textBox2.Text.Replace(",", "."), CultureInfo.InvariantCulture);
double miterLimit = double.Parse(textBox3.Text.Replace(",", "."), CultureInfo.InvariantCulture);
double curveTolerance = double.Parse(textBox4.Text.Replace(",", "."), CultureInfo.InvariantCulture);
p.Points = ar1[0].Polygon.Points.Select(z => new SvgPoint(z.X, z.Y)).ToArray();
p2.Points = ar1[1].Polygon.Points.Select(z => new SvgPoint(z.X, z.Y)).ToArray();
var offs = ClipperHelper.intersection(p, p2, offset, jType, curveTolerance: curveTolerance, miterLimit: miterLimit);
PolygonHelper ph = new PolygonHelper();
if (offs.Any())
{
ph.Polygon.Points = offs.First().Points.Select(z => new SvgPoint(z.X, z.Y)).ToArray();
}
foreach (var item in offs.Skip(1))
{
var nfp2 = new NFP();
nfp2.Points = item.Points.Select(z => new SvgPoint(z.X, z.Y)).ToArray();
ph.Polygon.Childrens.Add(nfp2);
}
dataModel.AddItem(ph);
}
/**
* Returns whether a point is inside the exit
*
* @param x
* the horizontal positon
* @param y
* the vertical position
* @return true if the point (x, y) is inside the exit, false otherwise
*/
public bool isPointInside(int x, int y)
{
if (rectangular)
{
return(x > getX0() && x < getX1() && y > getY0() && y < getY1());
}
else
{
return(PolygonHelper.ContainsPoint(getPoints(), new Vector2(x, y)));
}
}
private void polygonToolStripMenuItem_Click(object sender, EventArgs e)
{
var ph = new PolygonHelper()
{
};
Helpers.Add(ph);
ph.Verticies.Add(new Vector3d(0, 0, 0));
ph.Verticies.Add(new Vector3d(6, 2, 0));
ph.Verticies.Add(new Vector3d(6, 6, 0));
ph.Verticies.Add(new Vector3d(0, 8, 0));
updateHelpersList();
}
private void button1_Click(object sender, EventArgs e)
{
NFP p = new NFP();
if (!(dataModel.SelectedItem is PolygonHelper ph2))
{
return;
}
p.Points = ph2.Polygon.Points.Select(z => new SvgPoint(z.X, z.Y)).ToArray();
var jType = (JoinType)comboBox1.SelectedIndex;
double offset = double.Parse(textBox2.Text.Replace(",", "."), CultureInfo.InvariantCulture);
double miterLimit = double.Parse(textBox3.Text.Replace(",", "."), CultureInfo.InvariantCulture);
double curveTolerance = double.Parse(textBox4.Text.Replace(",", "."), CultureInfo.InvariantCulture);
var offs = ClipperHelper.offset(p, offset, jType, curveTolerance: curveTolerance, miterLimit: miterLimit);
//if (offs.Count() > 1) throw new NotImplementedException();
PolygonHelper ph = new PolygonHelper();
foreach (var item in ph2.Polygon.Childrens)
{
var offs2 = ClipperHelper.offset(item, -offset, jType, curveTolerance: curveTolerance, miterLimit: miterLimit);
var nfp1 = new NFP();
if (offs2.Any())
{
//if (offs2.Count() > 1) throw new NotImplementedException();
foreach (var zitem in offs2)
{
nfp1.Points = zitem.Points.Select(z => new SvgPoint(z.X, z.Y)).ToArray();
ph.Polygon.Childrens.Add(nfp1);
}
}
}
if (offs.Any())
{
ph.Polygon.Points = offs.First().Points.Select(z => new SvgPoint(z.X, z.Y)).ToArray();
}
foreach (var item in offs.Skip(1))
{
var nfp2 = new NFP();
nfp2.Points = item.Points.Select(z => new SvgPoint(z.X, z.Y)).ToArray();
ph.Polygon.Childrens.Add(nfp2);
}
ph.OffsetX = ph2.OffsetX;
ph.OffsetY = ph2.OffsetY;
ph.Rotation = ph2.Rotation;
dataModel.AddItem(ph);
}
private float CalculateTriangles(SerializedProperty originProp, SerializedProperty vertexesProp,
SerializedProperty trianglesProp, SerializedProperty triangleAreasProp)
{
Vector3[] vertexes = new Vector3[vertexesProp.arraySize];
float area = 0;
for (int i = 0; i < vertexesProp.arraySize; ++i)
{
vertexes[i] = vertexesProp.GetArrayElementAtIndex(i).vector3Value;
}
originProp.vector3Value = PolygonAreaExtend.GetCentroid(vertexes.ToList());
Undo.RecordObject(((MonoBehaviour)target).gameObject, "Position");
((MonoBehaviour)target).transform.position = originProp.vector3Value;
PolygonHelper.Triangulate(vertexes, -GetPlane(originProp.vector3Value).normal, out var triangles);
if (triangles.Count != trianglesProp.arraySize)
{
trianglesProp.ClearArray();
for (int i = 0; i < triangles.Count; ++i)
{
trianglesProp.InsertArrayElementAtIndex(i);
}
}
if (triangles.Count != triangleAreasProp.arraySize)
{
triangleAreasProp.ClearArray();
for (int i = 0; i < triangles.Count; ++i)
{
triangleAreasProp.InsertArrayElementAtIndex(i);
}
}
for (int i = 0; i < triangles.Count; ++i)
{
var prop = trianglesProp.GetArrayElementAtIndex(i);
var tri = triangles[i];
prop.FindPropertyRelative("x").vector3Value = tri.x;
prop.FindPropertyRelative("y").vector3Value = tri.y;
prop.FindPropertyRelative("z").vector3Value = tri.z;
var areaProp = triangleAreasProp.GetArrayElementAtIndex(i);
areaProp.floatValue = tri.CalcTriangleArea();
area += areaProp.floatValue;
}
return(area);
}
public void AreaFail1()
{
var points = new Point[]
{
new Point(-5.26, 3.37),
new Point(-1.26, 0),
};
var(a, e) = PolygonHelper.Area(points);
Console.WriteLine($"Error:{e.ToString()}\r\nAnswer:{a.ToString(PrecisionPoly)}");
Assert.AreEqual(Errors.NeedMorePoints, e);
Assert.AreEqual((-1).ToString(PrecisionPoly), a.ToString(PrecisionPoly));
}
/// <summary>
/// Initializes a new instance of the <see cref="OoPolygonPointsObserver" /> class.
/// </summary>
/// <param name="shape">The corresponding shape.</param>
/// <exception cref="ArgumentNullException">shape</exception>
/// <exception cref="ArgumentException">shape must be a polygon or a bezier curve;shape</exception>
public OoPolygonPointsObserver(OoShapeObserver shape)
{
if (shape == null)
{
throw new ArgumentNullException("shape");
}
if (!PolygonHelper.IsFreeform(shape.Shape))
{
throw new ArgumentException("shape must be a polygon or a bezier curve", "shape");
}
Shape = shape;
Shape.BoundRectChangeEventHandlers += Shape_BoundRectChangeEventHandlers;
Shape.ObserverDisposing += Shape_ObserverDisposing;
Update();
IsEmpty = false;
}
bool lineIntersecOutline(Line line, List <XYZ> outline)
{
var points = outline.Select(m => m.ProjectToXLine(line));
points = points.Where(m => m.IsOnLine(line));
foreach (var point in points)
{
var newpoint = new XYZ(point.X, point.Y, outline.First().Z);
var inpolygon = PolygonHelper.IsPointInRegion(newpoint, outline, XYZ.BasisZ);
if (inpolygon)
{
return(true);
}
}
return(false);
}
public static PolyBoolCS.Polygon GetPolygon(this PolygonHelper ph)
{
var p = new PolyBoolCS.Polygon();
p.regions = new List <PointList>();
var pnts = ph.Polygon.Points.Select(z => ph.Transform(z)).ToArray();
PointList plist = GetPointList(pnts);
p.regions.Add(plist);
foreach (var item in ph.Polygon.Childrens)
{
pnts = item.Points.Select(z => ph.Transform(z)).ToArray();
plist = GetPointList(pnts);
p.regions.Add(plist);
}
return(p);
}
public void AreaOk4()
{
var points = new Point[]
{
new Point(-5.26, 3.37),
new Point(-5.26, double.PositiveInfinity),
new Point(-5.26, 3.37),
};
var etalon = double.NaN;
var(a, e) = PolygonHelper.Area(points);
Console.WriteLine($"Error:{e.ToString()}\r\nAnswer:{a.ToString(PrecisionPoly)}\r\nEtalon:{etalon.ToString(PrecisionPoly)}");
Assert.AreEqual(Errors.None, e);
Assert.AreEqual(etalon.ToString(PrecisionPoly), a.ToString(PrecisionPoly));
}
private void button4_Click(object sender, EventArgs e)
{
if (!(dataModel.SelectedItem is PolygonHelper ph2))
{
return;
}
var hull = DeepNest.getHull(new NFP()
{
Points = ph2.TransformedPoints()
});
PolygonHelper ph = new PolygonHelper();
ph.Polygon = hull;
ph.Name = "hull";
dataModel.AddItem(ph);
}
/// <summary>
/// Writes the points to polygons properties.
/// </summary>
/// <param name="geometry">if set to <c>true</c> the 'Geometry' property is used (these are the untransformed coordinates of the polygon).
/// <returns><c>true</c> if the points could be written to the properties</returns>
virtual public bool WritePointsToPolygon(bool geometry = false)
{
if (IsValid())
{
OoShapeObserver.LockValidation = true;
try
{
bool success = PolygonHelper.SetPolyPoints(Shape.Shape, CachedPolyPointList, geometry, Shape.GetDocument());
Update();
return(success);
}
finally
{
OoShapeObserver.LockValidation = false;
}
}
return(false);
}
/// <summary>
/// Sets the poly point list.
/// </summary>
/// <param name="newPoints">The new points.</param>
/// <param name="geometry">if set to <c>true</c> the 'Geometry' property is used (these are the untransformed coordinates of the polygon).
/// <returns><c>true</c> if the points could be written to the properties</returns>
virtual public bool SetPolyPointList(List <List <PolyPointDescriptor> > newPoints, bool geometry = false)
{
if (IsValid())
{
OoShapeObserver.LockValidation = true;
try
{
bool success = PolygonHelper.SetPolyPoints(Shape.Shape, newPoints, geometry, Shape.GetDocument());
Update();
return(success);
}
finally
{
OoShapeObserver.LockValidation = false;
}
}
return(false);
}
private void button7_Click(object sender, EventArgs e)
{
if (!(dataModel.SelectedItem is PolygonHelper ph2))
{
return;
}
double clipperScale = 10000000;
var hull = DeepNest.simplifyFunction(new NFP()
{
Points = ph2.TransformedPoints()
}, false, clipperScale);
PolygonHelper ph = new PolygonHelper();
ph.Polygon = hull;
ph.Name = "simplify";
dataModel.AddItem(ph);
}
private void button12_Click(object sender, EventArgs e)
{
var res = dataModel.GetPairOfSelectedNfps();
if (res == null)
{
return;
}
NFP offs = null;
offs = ClipperHelper.MinkowskiSum(res[0], res[1], checkBox2.Checked, checkBox3.Checked);
if (offs != null)
{
PolygonHelper ph = new PolygonHelper();
//ph.Polygon.Points = offs.Points.Select(z => new SvgPoint(z.X, z.Y)).ToArray();
ph.Polygon = DeepNest.clone2(offs);
dataModel.AddItem(ph);
}
}
private void extractChildsToolStripMenuItem_Click(object sender, EventArgs e)
{
if (dataModel.SelectedItems.Length == 0)
{
return;
}
var hh = dataModel.SelectedItem;
if (!(hh is PolygonHelper ph))
{
return;
}
foreach (var item in ph.Polygon.Childrens)
{
PolygonHelper ph2 = new PolygonHelper();
ph2.Polygon = DeepNest.clone(item);
dataModel.AddItem(ph2);
}
}
public void AreaOk1()
{
var points = new Point[]
{
new Point(-5.26, 3.37),
new Point(-3.66, -2.67),
new Point(5.84, -1.55),
new Point(1.36, 0.79),
new Point(2.2, 6.27),
new Point(-1.68, 1.61)
};
var etalon = 39.02;
var(a, e) = PolygonHelper.Area(points);
Console.WriteLine($"Error:{e.ToString()}\r\nAnswer:{a.ToString(PrecisionPoly)}\r\nEtalon:{etalon.ToString(PrecisionPoly)}");
Assert.AreEqual(Errors.None, e);
Assert.AreEqual(etalon.ToString(PrecisionPoly), a.ToString(PrecisionPoly));
}
private void button13_Click(object sender, EventArgs e)
{
var res = dataModel.GetPairOfSelectedNfps();
if (res == null)
{
return;
}
var p = res[0];
var p2 = res[1];
var offs = DeepNest.getOuterNfp(p, p2);
if (offs != null)
{
PolygonHelper ph = new PolygonHelper();
//ph.Polygon.Points = offs.Points.Select(z => new SvgPoint(z.X, z.Y)).ToArray();
ph.Polygon = DeepNest.clone2(offs);
dataModel.AddItem(ph);
}
}
/// <summary>
/// Sets the poly polygon points to the shape.
/// </summary>
/// <param name="points">The points.</param>
virtual public void SetPolyPolygonPoints(List <List <PolyPointDescriptor> > points)
{
//System.Diagnostics.Stopwatch watch = new System.Diagnostics.Stopwatch();
//watch.Restart();
try
{
Task t = new Task(
() =>
{
LockValidation = true;
try { PolygonHelper.SetPolyPoints(Shape, points, false, GetDocument()); }
finally { LockValidation = false; }
}
);
t.Start();
}
finally
{
//watch.Stop();
//System.Diagnostics.Debug.WriteLine("Ticks for handling Polygon setting Points:" + watch.ElapsedTicks + " / Milliseconds:" + watch.ElapsedMilliseconds);
}
}
private void button15_Click(object sender, EventArgs e)
{
var res = dataModel.GetPairOfSelectedNfps();
if (res == null)
{
return;
}
var p = res[0];
var p2 = res[1];
var offs = DeepNest.Convolve(p2, p);
if (offs != null)
{
foreach (var item in offs)
{
PolygonHelper ph = new PolygonHelper();
//ph.Polygon.Points = item.Points.Select(z => new SvgPoint(z.X, z.Y)).ToArray();
ph.Polygon = DeepNest.clone2(item);
dataModel.AddItem(ph);
}
}
}
/// <summary>
/// Gets the direct access to the poly polygon points.
/// </summary>
/// <returns>list of polygon point lists</returns>
virtual public List <List <PolyPointDescriptor> > GetPolyPolygonPoints()
{
var points = PolygonHelper.GetPolyPoints(Shape);
return(points);
}
