2446 lines
73 KiB
C#
2446 lines
73 KiB
C#
using System;
|
|
using TriangleNet.Geometry;
|
|
using TriangleNet.Tools;
|
|
using TriangleNet.Topology;
|
|
|
|
namespace TriangleNet
|
|
{
|
|
internal class NewLocation
|
|
{
|
|
private const double EPS = 1E-50;
|
|
|
|
private IPredicates predicates;
|
|
|
|
private Mesh mesh;
|
|
|
|
private Behavior behavior;
|
|
|
|
private double[] petalx = new double[20];
|
|
|
|
private double[] petaly = new double[20];
|
|
|
|
private double[] petalr = new double[20];
|
|
|
|
private double[] wedges = new double[500];
|
|
|
|
private double[] initialConvexPoly = new double[500];
|
|
|
|
private double[] points_p = new double[500];
|
|
|
|
private double[] points_q = new double[500];
|
|
|
|
private double[] points_r = new double[500];
|
|
|
|
private double[] poly1 = new double[100];
|
|
|
|
private double[] poly2 = new double[100];
|
|
|
|
private double[][] polys = new double[3][];
|
|
|
|
public NewLocation(Mesh mesh, IPredicates predicates)
|
|
{
|
|
this.mesh = mesh;
|
|
this.predicates = predicates;
|
|
behavior = mesh.behavior;
|
|
}
|
|
|
|
public Point FindLocation(Vertex org, Vertex dest, Vertex apex, ref double xi, ref double eta, bool offcenter, Otri badotri)
|
|
{
|
|
if (behavior.MaxAngle == 0.0)
|
|
{
|
|
return FindNewLocationWithoutMaxAngle(org, dest, apex, ref xi, ref eta, offcenter: true, badotri);
|
|
}
|
|
return FindNewLocation(org, dest, apex, ref xi, ref eta, offcenter: true, badotri);
|
|
}
|
|
|
|
private Point FindNewLocationWithoutMaxAngle(Vertex torg, Vertex tdest, Vertex tapex, ref double xi, ref double eta, bool offcenter, Otri badotri)
|
|
{
|
|
double offconstant = behavior.offconstant;
|
|
double num = 0.0;
|
|
double num2 = 0.0;
|
|
double num3 = 0.0;
|
|
double num4 = 0.0;
|
|
double num5 = 0.0;
|
|
int num6 = 0;
|
|
int num7 = 0;
|
|
Otri neighotri = default(Otri);
|
|
double[] thirdpoint = new double[2];
|
|
double xi2 = 0.0;
|
|
double eta2 = 0.0;
|
|
double[] p = new double[5];
|
|
double[] p2 = new double[4];
|
|
double num8 = 0.06;
|
|
double num9 = 1.0;
|
|
double num10 = 1.0;
|
|
int num11 = 0;
|
|
double[] newloc = new double[2];
|
|
double num12 = 0.0;
|
|
double num13 = 0.0;
|
|
Statistic.CircumcenterCount++;
|
|
double num14 = tdest.x - torg.x;
|
|
double num15 = tdest.y - torg.y;
|
|
double num16 = tapex.x - torg.x;
|
|
double num17 = tapex.y - torg.y;
|
|
double num18 = tapex.x - tdest.x;
|
|
double num19 = tapex.y - tdest.y;
|
|
double num20 = num14 * num14 + num15 * num15;
|
|
double num21 = num16 * num16 + num17 * num17;
|
|
double num22 = (tdest.x - tapex.x) * (tdest.x - tapex.x) + (tdest.y - tapex.y) * (tdest.y - tapex.y);
|
|
double num23;
|
|
if (Behavior.NoExact)
|
|
{
|
|
num23 = 0.5 / (num14 * num17 - num16 * num15);
|
|
}
|
|
else
|
|
{
|
|
num23 = 0.5 / predicates.CounterClockwise(tdest, tapex, torg);
|
|
Statistic.CounterClockwiseCount--;
|
|
}
|
|
double num24 = (num17 * num20 - num15 * num21) * num23;
|
|
double num25 = (num14 * num21 - num16 * num20) * num23;
|
|
Point point = new Point(torg.x + num24, torg.y + num25);
|
|
Otri deltri = badotri;
|
|
num6 = LongestShortestEdge(num21, num22, num20);
|
|
Point point2;
|
|
Point point3;
|
|
Point point4;
|
|
switch (num6)
|
|
{
|
|
case 123:
|
|
num = num16;
|
|
num2 = num17;
|
|
num3 = num21;
|
|
num4 = num22;
|
|
num5 = num20;
|
|
point2 = tdest;
|
|
point3 = torg;
|
|
point4 = tapex;
|
|
break;
|
|
case 132:
|
|
num = num16;
|
|
num2 = num17;
|
|
num3 = num21;
|
|
num4 = num20;
|
|
num5 = num22;
|
|
point2 = tdest;
|
|
point3 = tapex;
|
|
point4 = torg;
|
|
break;
|
|
case 213:
|
|
num = num18;
|
|
num2 = num19;
|
|
num3 = num22;
|
|
num4 = num21;
|
|
num5 = num20;
|
|
point2 = torg;
|
|
point3 = tdest;
|
|
point4 = tapex;
|
|
break;
|
|
case 231:
|
|
num = num18;
|
|
num2 = num19;
|
|
num3 = num22;
|
|
num4 = num20;
|
|
num5 = num21;
|
|
point2 = torg;
|
|
point3 = tapex;
|
|
point4 = tdest;
|
|
break;
|
|
case 312:
|
|
num = num14;
|
|
num2 = num15;
|
|
num3 = num20;
|
|
num4 = num21;
|
|
num5 = num22;
|
|
point2 = tapex;
|
|
point3 = tdest;
|
|
point4 = torg;
|
|
break;
|
|
default:
|
|
num = num14;
|
|
num2 = num15;
|
|
num3 = num20;
|
|
num4 = num22;
|
|
num5 = num21;
|
|
point2 = tapex;
|
|
point3 = torg;
|
|
point4 = tdest;
|
|
break;
|
|
}
|
|
if (offcenter && offconstant > 0.0)
|
|
{
|
|
switch (num6)
|
|
{
|
|
case 213:
|
|
case 231:
|
|
{
|
|
double num26 = 0.5 * num - offconstant * num2;
|
|
double num27 = 0.5 * num2 + offconstant * num;
|
|
if (num26 * num26 + num27 * num27 < (num24 - num14) * (num24 - num14) + (num25 - num15) * (num25 - num15))
|
|
{
|
|
num24 = num14 + num26;
|
|
num25 = num15 + num27;
|
|
}
|
|
else
|
|
{
|
|
num7 = 1;
|
|
}
|
|
break;
|
|
}
|
|
case 123:
|
|
case 132:
|
|
{
|
|
double num26 = 0.5 * num + offconstant * num2;
|
|
double num27 = 0.5 * num2 - offconstant * num;
|
|
if (num26 * num26 + num27 * num27 < num24 * num24 + num25 * num25)
|
|
{
|
|
num24 = num26;
|
|
num25 = num27;
|
|
}
|
|
else
|
|
{
|
|
num7 = 1;
|
|
}
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
double num26 = 0.5 * num - offconstant * num2;
|
|
double num27 = 0.5 * num2 + offconstant * num;
|
|
if (num26 * num26 + num27 * num27 < num24 * num24 + num25 * num25)
|
|
{
|
|
num24 = num26;
|
|
num25 = num27;
|
|
}
|
|
else
|
|
{
|
|
num7 = 1;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if (num7 == 1)
|
|
{
|
|
double num28 = (num4 + num3 - num5) / (2.0 * Math.Sqrt(num4) * Math.Sqrt(num3));
|
|
bool flag = num28 < 0.0 || Math.Abs(num28 - 0.0) <= 1E-50;
|
|
num11 = DoSmoothing(deltri, torg, tdest, tapex, ref newloc);
|
|
if (num11 > 0)
|
|
{
|
|
Statistic.RelocationCount++;
|
|
num24 = newloc[0] - torg.x;
|
|
num25 = newloc[1] - torg.y;
|
|
num12 = torg.x;
|
|
num13 = torg.y;
|
|
switch (num11)
|
|
{
|
|
case 1:
|
|
mesh.DeleteVertex(ref deltri);
|
|
break;
|
|
case 2:
|
|
deltri.Lnext();
|
|
mesh.DeleteVertex(ref deltri);
|
|
break;
|
|
case 3:
|
|
deltri.Lprev();
|
|
mesh.DeleteVertex(ref deltri);
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
double num29 = Math.Sqrt(num3) / (2.0 * Math.Sin(behavior.MinAngle * Math.PI / 180.0));
|
|
double num30 = (point3.x + point4.x) / 2.0;
|
|
double num31 = (point3.y + point4.y) / 2.0;
|
|
double num32 = num30 + Math.Sqrt(num29 * num29 - num3 / 4.0) * (point3.y - point4.y) / Math.Sqrt(num3);
|
|
double num33 = num31 + Math.Sqrt(num29 * num29 - num3 / 4.0) * (point4.x - point3.x) / Math.Sqrt(num3);
|
|
double num34 = num30 - Math.Sqrt(num29 * num29 - num3 / 4.0) * (point3.y - point4.y) / Math.Sqrt(num3);
|
|
double num35 = num31 - Math.Sqrt(num29 * num29 - num3 / 4.0) * (point4.x - point3.x) / Math.Sqrt(num3);
|
|
double num36 = (num32 - point2.x) * (num32 - point2.x);
|
|
double num37 = (num33 - point2.y) * (num33 - point2.y);
|
|
double num38 = (num34 - point2.x) * (num34 - point2.x);
|
|
double num39 = (num35 - point2.y) * (num35 - point2.y);
|
|
double x;
|
|
double y;
|
|
if (num36 + num37 <= num38 + num39)
|
|
{
|
|
x = num32;
|
|
y = num33;
|
|
}
|
|
else
|
|
{
|
|
x = num34;
|
|
y = num35;
|
|
}
|
|
bool neighborsVertex = GetNeighborsVertex(badotri, point3.x, point3.y, point2.x, point2.y, ref thirdpoint, ref neighotri);
|
|
double num40 = num24;
|
|
double num41 = num25;
|
|
if (!neighborsVertex)
|
|
{
|
|
Vertex org = neighotri.Org();
|
|
Vertex dest = neighotri.Dest();
|
|
Vertex apex = neighotri.Apex();
|
|
Point point5 = predicates.FindCircumcenter(org, dest, apex, ref xi2, ref eta2);
|
|
double num42 = point3.y - point2.y;
|
|
double num43 = point2.x - point3.x;
|
|
num42 = point.x + num42;
|
|
num43 = point.y + num43;
|
|
CircleLineIntersection(point.x, point.y, num42, num43, x, y, num29, ref p);
|
|
double x2 = (point3.x + point2.x) / 2.0;
|
|
double y2 = (point3.y + point2.y) / 2.0;
|
|
double num44;
|
|
double num45;
|
|
if (ChooseCorrectPoint(x2, y2, p[3], p[4], point.x, point.y, flag))
|
|
{
|
|
num44 = p[3];
|
|
num45 = p[4];
|
|
}
|
|
else
|
|
{
|
|
num44 = p[1];
|
|
num45 = p[2];
|
|
}
|
|
PointBetweenPoints(num44, num45, point.x, point.y, point5.x, point5.y, ref p2);
|
|
if (p[0] > 0.0)
|
|
{
|
|
if (Math.Abs(p2[0] - 1.0) <= 1E-50)
|
|
{
|
|
if (IsBadTriangleAngle(point3.x, point3.y, point4.x, point4.y, point5.x, point5.y))
|
|
{
|
|
num40 = num24;
|
|
num41 = num25;
|
|
}
|
|
else
|
|
{
|
|
num40 = p2[2] - torg.x;
|
|
num41 = p2[3] - torg.y;
|
|
}
|
|
}
|
|
else if (IsBadTriangleAngle(point4.x, point4.y, point3.x, point3.y, num44, num45))
|
|
{
|
|
double num46 = Math.Sqrt((num44 - point.x) * (num44 - point.x) + (num45 - point.y) * (num45 - point.y));
|
|
double num47 = point.x - num44;
|
|
double num48 = point.y - num45;
|
|
num47 /= num46;
|
|
num48 /= num46;
|
|
num44 += num47 * num8 * Math.Sqrt(num3);
|
|
num45 += num48 * num8 * Math.Sqrt(num3);
|
|
if (IsBadTriangleAngle(point3.x, point3.y, point4.x, point4.y, num44, num45))
|
|
{
|
|
num40 = num24;
|
|
num41 = num25;
|
|
}
|
|
else
|
|
{
|
|
num40 = num44 - torg.x;
|
|
num41 = num45 - torg.y;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
num40 = num44 - torg.x;
|
|
num41 = num45 - torg.y;
|
|
}
|
|
if ((point2.x - point.x) * (point2.x - point.x) + (point2.y - point.y) * (point2.y - point.y) > num9 * ((point2.x - (num40 + torg.x)) * (point2.x - (num40 + torg.x)) + (point2.y - (num41 + torg.y)) * (point2.y - (num41 + torg.y))))
|
|
{
|
|
num40 = num24;
|
|
num41 = num25;
|
|
}
|
|
}
|
|
}
|
|
bool neighborsVertex2 = GetNeighborsVertex(badotri, point4.x, point4.y, point2.x, point2.y, ref thirdpoint, ref neighotri);
|
|
double num49 = num24;
|
|
double num50 = num25;
|
|
if (!neighborsVertex2)
|
|
{
|
|
Vertex org = neighotri.Org();
|
|
Vertex dest = neighotri.Dest();
|
|
Vertex apex = neighotri.Apex();
|
|
Point point5 = predicates.FindCircumcenter(org, dest, apex, ref xi2, ref eta2);
|
|
double num42 = point4.y - point2.y;
|
|
double num43 = point2.x - point4.x;
|
|
num42 = point.x + num42;
|
|
num43 = point.y + num43;
|
|
CircleLineIntersection(point.x, point.y, num42, num43, x, y, num29, ref p);
|
|
double x3 = (point4.x + point2.x) / 2.0;
|
|
double y3 = (point4.y + point2.y) / 2.0;
|
|
double num44;
|
|
double num45;
|
|
if (ChooseCorrectPoint(x3, y3, p[3], p[4], point.x, point.y, isObtuse: false))
|
|
{
|
|
num44 = p[3];
|
|
num45 = p[4];
|
|
}
|
|
else
|
|
{
|
|
num44 = p[1];
|
|
num45 = p[2];
|
|
}
|
|
PointBetweenPoints(num44, num45, point.x, point.y, point5.x, point5.y, ref p2);
|
|
if (p[0] > 0.0)
|
|
{
|
|
if (Math.Abs(p2[0] - 1.0) <= 1E-50)
|
|
{
|
|
if (IsBadTriangleAngle(point3.x, point3.y, point4.x, point4.y, point5.x, point5.y))
|
|
{
|
|
num49 = num24;
|
|
num50 = num25;
|
|
}
|
|
else
|
|
{
|
|
num49 = p2[2] - torg.x;
|
|
num50 = p2[3] - torg.y;
|
|
}
|
|
}
|
|
else if (IsBadTriangleAngle(point3.x, point3.y, point4.x, point4.y, num44, num45))
|
|
{
|
|
double num46 = Math.Sqrt((num44 - point.x) * (num44 - point.x) + (num45 - point.y) * (num45 - point.y));
|
|
double num47 = point.x - num44;
|
|
double num48 = point.y - num45;
|
|
num47 /= num46;
|
|
num48 /= num46;
|
|
num44 += num47 * num8 * Math.Sqrt(num3);
|
|
num45 += num48 * num8 * Math.Sqrt(num3);
|
|
if (IsBadTriangleAngle(point3.x, point3.y, point4.x, point4.y, num44, num45))
|
|
{
|
|
num49 = num24;
|
|
num50 = num25;
|
|
}
|
|
else
|
|
{
|
|
num49 = num44 - torg.x;
|
|
num50 = num45 - torg.y;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
num49 = num44 - torg.x;
|
|
num50 = num45 - torg.y;
|
|
}
|
|
if ((point2.x - point.x) * (point2.x - point.x) + (point2.y - point.y) * (point2.y - point.y) > num9 * ((point2.x - (num49 + torg.x)) * (point2.x - (num49 + torg.x)) + (point2.y - (num50 + torg.y)) * (point2.y - (num50 + torg.y))))
|
|
{
|
|
num49 = num24;
|
|
num50 = num25;
|
|
}
|
|
}
|
|
}
|
|
if (flag)
|
|
{
|
|
num24 = num40;
|
|
num25 = num41;
|
|
}
|
|
else if (num10 * ((point2.x - (num49 + torg.x)) * (point2.x - (num49 + torg.x)) + (point2.y - (num50 + torg.y)) * (point2.y - (num50 + torg.y))) > (point2.x - (num40 + torg.x)) * (point2.x - (num40 + torg.x)) + (point2.y - (num41 + torg.y)) * (point2.y - (num41 + torg.y)))
|
|
{
|
|
num24 = num49;
|
|
num25 = num50;
|
|
}
|
|
else
|
|
{
|
|
num24 = num40;
|
|
num25 = num41;
|
|
}
|
|
}
|
|
}
|
|
Point point6 = new Point();
|
|
if (num11 <= 0)
|
|
{
|
|
point6.x = torg.x + num24;
|
|
point6.y = torg.y + num25;
|
|
}
|
|
else
|
|
{
|
|
point6.x = num12 + num24;
|
|
point6.y = num13 + num25;
|
|
}
|
|
xi = (num17 * num24 - num16 * num25) * (2.0 * num23);
|
|
eta = (num14 * num25 - num15 * num24) * (2.0 * num23);
|
|
return point6;
|
|
}
|
|
|
|
private Point FindNewLocation(Vertex torg, Vertex tdest, Vertex tapex, ref double xi, ref double eta, bool offcenter, Otri badotri)
|
|
{
|
|
double offconstant = behavior.offconstant;
|
|
double num = 0.0;
|
|
double num2 = 0.0;
|
|
double num3 = 0.0;
|
|
double num4 = 0.0;
|
|
double num5 = 0.0;
|
|
int num6 = 0;
|
|
int num7 = 0;
|
|
Otri neighotri = default(Otri);
|
|
double[] thirdpoint = new double[2];
|
|
double xi2 = 0.0;
|
|
double eta2 = 0.0;
|
|
double[] p = new double[5];
|
|
double[] p2 = new double[4];
|
|
double num8 = 0.06;
|
|
double num9 = 1.0;
|
|
double num10 = 1.0;
|
|
int num11 = 0;
|
|
double[] newloc = new double[2];
|
|
double num12 = 0.0;
|
|
double num13 = 0.0;
|
|
double num14 = 0.0;
|
|
double num15 = 0.0;
|
|
double[] p3 = new double[3];
|
|
double[] p4 = new double[4];
|
|
Statistic.CircumcenterCount++;
|
|
double num16 = tdest.x - torg.x;
|
|
double num17 = tdest.y - torg.y;
|
|
double num18 = tapex.x - torg.x;
|
|
double num19 = tapex.y - torg.y;
|
|
double num20 = tapex.x - tdest.x;
|
|
double num21 = tapex.y - tdest.y;
|
|
double num22 = num16 * num16 + num17 * num17;
|
|
double num23 = num18 * num18 + num19 * num19;
|
|
double num24 = (tdest.x - tapex.x) * (tdest.x - tapex.x) + (tdest.y - tapex.y) * (tdest.y - tapex.y);
|
|
double num25;
|
|
if (Behavior.NoExact)
|
|
{
|
|
num25 = 0.5 / (num16 * num19 - num18 * num17);
|
|
}
|
|
else
|
|
{
|
|
num25 = 0.5 / predicates.CounterClockwise(tdest, tapex, torg);
|
|
Statistic.CounterClockwiseCount--;
|
|
}
|
|
double num26 = (num19 * num22 - num17 * num23) * num25;
|
|
double num27 = (num16 * num23 - num18 * num22) * num25;
|
|
Point point = new Point(torg.x + num26, torg.y + num27);
|
|
Otri deltri = badotri;
|
|
num6 = LongestShortestEdge(num23, num24, num22);
|
|
Point point2;
|
|
Point point3;
|
|
Point point4;
|
|
switch (num6)
|
|
{
|
|
case 123:
|
|
num = num18;
|
|
num2 = num19;
|
|
num3 = num23;
|
|
num4 = num24;
|
|
num5 = num22;
|
|
point2 = tdest;
|
|
point3 = torg;
|
|
point4 = tapex;
|
|
break;
|
|
case 132:
|
|
num = num18;
|
|
num2 = num19;
|
|
num3 = num23;
|
|
num4 = num22;
|
|
num5 = num24;
|
|
point2 = tdest;
|
|
point3 = tapex;
|
|
point4 = torg;
|
|
break;
|
|
case 213:
|
|
num = num20;
|
|
num2 = num21;
|
|
num3 = num24;
|
|
num4 = num23;
|
|
num5 = num22;
|
|
point2 = torg;
|
|
point3 = tdest;
|
|
point4 = tapex;
|
|
break;
|
|
case 231:
|
|
num = num20;
|
|
num2 = num21;
|
|
num3 = num24;
|
|
num4 = num22;
|
|
num5 = num23;
|
|
point2 = torg;
|
|
point3 = tapex;
|
|
point4 = tdest;
|
|
break;
|
|
case 312:
|
|
num = num16;
|
|
num2 = num17;
|
|
num3 = num22;
|
|
num4 = num23;
|
|
num5 = num24;
|
|
point2 = tapex;
|
|
point3 = tdest;
|
|
point4 = torg;
|
|
break;
|
|
default:
|
|
num = num16;
|
|
num2 = num17;
|
|
num3 = num22;
|
|
num4 = num24;
|
|
num5 = num23;
|
|
point2 = tapex;
|
|
point3 = torg;
|
|
point4 = tdest;
|
|
break;
|
|
}
|
|
if (offcenter && offconstant > 0.0)
|
|
{
|
|
switch (num6)
|
|
{
|
|
case 213:
|
|
case 231:
|
|
{
|
|
double num28 = 0.5 * num - offconstant * num2;
|
|
double num29 = 0.5 * num2 + offconstant * num;
|
|
if (num28 * num28 + num29 * num29 < (num26 - num16) * (num26 - num16) + (num27 - num17) * (num27 - num17))
|
|
{
|
|
num26 = num16 + num28;
|
|
num27 = num17 + num29;
|
|
}
|
|
else
|
|
{
|
|
num7 = 1;
|
|
}
|
|
break;
|
|
}
|
|
case 123:
|
|
case 132:
|
|
{
|
|
double num28 = 0.5 * num + offconstant * num2;
|
|
double num29 = 0.5 * num2 - offconstant * num;
|
|
if (num28 * num28 + num29 * num29 < num26 * num26 + num27 * num27)
|
|
{
|
|
num26 = num28;
|
|
num27 = num29;
|
|
}
|
|
else
|
|
{
|
|
num7 = 1;
|
|
}
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
double num28 = 0.5 * num - offconstant * num2;
|
|
double num29 = 0.5 * num2 + offconstant * num;
|
|
if (num28 * num28 + num29 * num29 < num26 * num26 + num27 * num27)
|
|
{
|
|
num26 = num28;
|
|
num27 = num29;
|
|
}
|
|
else
|
|
{
|
|
num7 = 1;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if (num7 == 1)
|
|
{
|
|
double num30 = (num4 + num3 - num5) / (2.0 * Math.Sqrt(num4) * Math.Sqrt(num3));
|
|
bool flag = num30 < 0.0 || Math.Abs(num30 - 0.0) <= 1E-50;
|
|
num11 = DoSmoothing(deltri, torg, tdest, tapex, ref newloc);
|
|
if (num11 > 0)
|
|
{
|
|
Statistic.RelocationCount++;
|
|
num26 = newloc[0] - torg.x;
|
|
num27 = newloc[1] - torg.y;
|
|
num12 = torg.x;
|
|
num13 = torg.y;
|
|
switch (num11)
|
|
{
|
|
case 1:
|
|
mesh.DeleteVertex(ref deltri);
|
|
break;
|
|
case 2:
|
|
deltri.Lnext();
|
|
mesh.DeleteVertex(ref deltri);
|
|
break;
|
|
case 3:
|
|
deltri.Lprev();
|
|
mesh.DeleteVertex(ref deltri);
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
double num31 = Math.Acos((num4 + num5 - num3) / (2.0 * Math.Sqrt(num4) * Math.Sqrt(num5))) * 180.0 / Math.PI;
|
|
num31 = ((!(behavior.MinAngle > num31)) ? (num31 + 0.5) : behavior.MinAngle);
|
|
double num32 = Math.Sqrt(num3) / (2.0 * Math.Sin(num31 * Math.PI / 180.0));
|
|
double num33 = (point3.x + point4.x) / 2.0;
|
|
double num34 = (point3.y + point4.y) / 2.0;
|
|
double num35 = num33 + Math.Sqrt(num32 * num32 - num3 / 4.0) * (point3.y - point4.y) / Math.Sqrt(num3);
|
|
double num36 = num34 + Math.Sqrt(num32 * num32 - num3 / 4.0) * (point4.x - point3.x) / Math.Sqrt(num3);
|
|
double num37 = num33 - Math.Sqrt(num32 * num32 - num3 / 4.0) * (point3.y - point4.y) / Math.Sqrt(num3);
|
|
double num38 = num34 - Math.Sqrt(num32 * num32 - num3 / 4.0) * (point4.x - point3.x) / Math.Sqrt(num3);
|
|
double num39 = (num35 - point2.x) * (num35 - point2.x);
|
|
double num40 = (num36 - point2.y) * (num36 - point2.y);
|
|
double num41 = (num37 - point2.x) * (num37 - point2.x);
|
|
double num42 = (num38 - point2.y) * (num38 - point2.y);
|
|
double num43;
|
|
double num44;
|
|
if (num39 + num40 <= num41 + num42)
|
|
{
|
|
num43 = num35;
|
|
num44 = num36;
|
|
}
|
|
else
|
|
{
|
|
num43 = num37;
|
|
num44 = num38;
|
|
}
|
|
bool neighborsVertex = GetNeighborsVertex(badotri, point3.x, point3.y, point2.x, point2.y, ref thirdpoint, ref neighotri);
|
|
double num45 = num26;
|
|
double num46 = num27;
|
|
double num47 = Math.Sqrt((num43 - num33) * (num43 - num33) + (num44 - num34) * (num44 - num34));
|
|
double num48 = (num43 - num33) / num47;
|
|
double num49 = (num44 - num34) / num47;
|
|
double num50 = num43 + num48 * num32;
|
|
double num51 = num44 + num49 * num32;
|
|
double num52 = (2.0 * behavior.MaxAngle + num31 - 180.0) * Math.PI / 180.0;
|
|
double num53 = num50 * Math.Cos(num52) + num51 * Math.Sin(num52) + num43 - num43 * Math.Cos(num52) - num44 * Math.Sin(num52);
|
|
double num54 = (0.0 - num50) * Math.Sin(num52) + num51 * Math.Cos(num52) + num44 + num43 * Math.Sin(num52) - num44 * Math.Cos(num52);
|
|
double num55 = num50 * Math.Cos(num52) - num51 * Math.Sin(num52) + num43 - num43 * Math.Cos(num52) + num44 * Math.Sin(num52);
|
|
double num56 = num50 * Math.Sin(num52) + num51 * Math.Cos(num52) + num44 - num43 * Math.Sin(num52) - num44 * Math.Cos(num52);
|
|
double num57;
|
|
double num58;
|
|
double num59;
|
|
double num60;
|
|
if (ChooseCorrectPoint(num55, num56, point3.x, point3.y, num53, num54, isObtuse: true))
|
|
{
|
|
num57 = num53;
|
|
num58 = num54;
|
|
num59 = num55;
|
|
num60 = num56;
|
|
}
|
|
else
|
|
{
|
|
num57 = num55;
|
|
num58 = num56;
|
|
num59 = num53;
|
|
num60 = num54;
|
|
}
|
|
double num61 = (point3.x + point2.x) / 2.0;
|
|
double num62 = (point3.y + point2.y) / 2.0;
|
|
if (!neighborsVertex)
|
|
{
|
|
Vertex org = neighotri.Org();
|
|
Vertex dest = neighotri.Dest();
|
|
Vertex apex = neighotri.Apex();
|
|
Point point5 = predicates.FindCircumcenter(org, dest, apex, ref xi2, ref eta2);
|
|
double num63 = point3.y - point2.y;
|
|
double num64 = point2.x - point3.x;
|
|
num63 = point.x + num63;
|
|
num64 = point.y + num64;
|
|
CircleLineIntersection(point.x, point.y, num63, num64, num43, num44, num32, ref p);
|
|
double num65;
|
|
double num66;
|
|
if (ChooseCorrectPoint(num61, num62, p[3], p[4], point.x, point.y, flag))
|
|
{
|
|
num65 = p[3];
|
|
num66 = p[4];
|
|
}
|
|
else
|
|
{
|
|
num65 = p[1];
|
|
num66 = p[2];
|
|
}
|
|
double x = point3.x;
|
|
double y = point3.y;
|
|
num48 = point4.x - point3.x;
|
|
num49 = point4.y - point3.y;
|
|
double x2 = num57;
|
|
double y2 = num58;
|
|
LineLineIntersection(point.x, point.y, num63, num64, x, y, x2, y2, ref p3);
|
|
if (p3[0] > 0.0)
|
|
{
|
|
num14 = p3[1];
|
|
num15 = p3[2];
|
|
}
|
|
PointBetweenPoints(num65, num66, point.x, point.y, point5.x, point5.y, ref p2);
|
|
if (p[0] > 0.0)
|
|
{
|
|
if (Math.Abs(p2[0] - 1.0) <= 1E-50)
|
|
{
|
|
PointBetweenPoints(p2[2], p2[3], point.x, point.y, num14, num15, ref p4);
|
|
if (Math.Abs(p4[0] - 1.0) <= 1E-50 && p3[0] > 0.0)
|
|
{
|
|
if ((point2.x - num57) * (point2.x - num57) + (point2.y - num58) * (point2.y - num58) > num9 * ((point2.x - num14) * (point2.x - num14) + (point2.y - num15) * (point2.y - num15)) && IsBadTriangleAngle(point3.x, point3.y, point4.x, point4.y, num57, num58) && MinDistanceToNeighbor(num57, num58, ref neighotri) > MinDistanceToNeighbor(num14, num15, ref neighotri))
|
|
{
|
|
num45 = num57 - torg.x;
|
|
num46 = num58 - torg.y;
|
|
}
|
|
else if (IsBadTriangleAngle(point3.x, point3.y, point4.x, point4.y, num14, num15))
|
|
{
|
|
double num67 = Math.Sqrt((num14 - point.x) * (num14 - point.x) + (num15 - point.y) * (num15 - point.y));
|
|
double num68 = point.x - num14;
|
|
double num69 = point.y - num15;
|
|
num68 /= num67;
|
|
num69 /= num67;
|
|
num14 += num68 * num8 * Math.Sqrt(num3);
|
|
num15 += num69 * num8 * Math.Sqrt(num3);
|
|
if (IsBadTriangleAngle(point3.x, point3.y, point4.x, point4.y, num14, num15))
|
|
{
|
|
num45 = num26;
|
|
num46 = num27;
|
|
}
|
|
else
|
|
{
|
|
num45 = num14 - torg.x;
|
|
num46 = num15 - torg.y;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
num45 = p4[2] - torg.x;
|
|
num46 = p4[3] - torg.y;
|
|
}
|
|
}
|
|
else if (IsBadTriangleAngle(point3.x, point3.y, point4.x, point4.y, point5.x, point5.y))
|
|
{
|
|
num45 = num26;
|
|
num46 = num27;
|
|
}
|
|
else
|
|
{
|
|
num45 = p2[2] - torg.x;
|
|
num46 = p2[3] - torg.y;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
PointBetweenPoints(num65, num66, point.x, point.y, num14, num15, ref p4);
|
|
if (Math.Abs(p4[0] - 1.0) <= 1E-50 && p3[0] > 0.0)
|
|
{
|
|
if ((point2.x - num57) * (point2.x - num57) + (point2.y - num58) * (point2.y - num58) > num9 * ((point2.x - num14) * (point2.x - num14) + (point2.y - num15) * (point2.y - num15)) && IsBadTriangleAngle(point3.x, point3.y, point4.x, point4.y, num57, num58) && MinDistanceToNeighbor(num57, num58, ref neighotri) > MinDistanceToNeighbor(num14, num15, ref neighotri))
|
|
{
|
|
num45 = num57 - torg.x;
|
|
num46 = num58 - torg.y;
|
|
}
|
|
else if (IsBadTriangleAngle(point4.x, point4.y, point3.x, point3.y, num14, num15))
|
|
{
|
|
double num67 = Math.Sqrt((num14 - point.x) * (num14 - point.x) + (num15 - point.y) * (num15 - point.y));
|
|
double num68 = point.x - num14;
|
|
double num69 = point.y - num15;
|
|
num68 /= num67;
|
|
num69 /= num67;
|
|
num14 += num68 * num8 * Math.Sqrt(num3);
|
|
num15 += num69 * num8 * Math.Sqrt(num3);
|
|
if (IsBadTriangleAngle(point3.x, point3.y, point4.x, point4.y, num14, num15))
|
|
{
|
|
num45 = num26;
|
|
num46 = num27;
|
|
}
|
|
else
|
|
{
|
|
num45 = num14 - torg.x;
|
|
num46 = num15 - torg.y;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
num45 = p4[2] - torg.x;
|
|
num46 = p4[3] - torg.y;
|
|
}
|
|
}
|
|
else if (IsBadTriangleAngle(point4.x, point4.y, point3.x, point3.y, num65, num66))
|
|
{
|
|
double num67 = Math.Sqrt((num65 - point.x) * (num65 - point.x) + (num66 - point.y) * (num66 - point.y));
|
|
double num68 = point.x - num65;
|
|
double num69 = point.y - num66;
|
|
num68 /= num67;
|
|
num69 /= num67;
|
|
num65 += num68 * num8 * Math.Sqrt(num3);
|
|
num66 += num69 * num8 * Math.Sqrt(num3);
|
|
if (IsBadTriangleAngle(point3.x, point3.y, point4.x, point4.y, num65, num66))
|
|
{
|
|
num45 = num26;
|
|
num46 = num27;
|
|
}
|
|
else
|
|
{
|
|
num45 = num65 - torg.x;
|
|
num46 = num66 - torg.y;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
num45 = num65 - torg.x;
|
|
num46 = num66 - torg.y;
|
|
}
|
|
}
|
|
if ((point2.x - point.x) * (point2.x - point.x) + (point2.y - point.y) * (point2.y - point.y) > num9 * ((point2.x - (num45 + torg.x)) * (point2.x - (num45 + torg.x)) + (point2.y - (num46 + torg.y)) * (point2.y - (num46 + torg.y))))
|
|
{
|
|
num45 = num26;
|
|
num46 = num27;
|
|
}
|
|
}
|
|
}
|
|
bool neighborsVertex2 = GetNeighborsVertex(badotri, point4.x, point4.y, point2.x, point2.y, ref thirdpoint, ref neighotri);
|
|
double num70 = num26;
|
|
double num71 = num27;
|
|
double num72 = (point4.x + point2.x) / 2.0;
|
|
double num73 = (point4.y + point2.y) / 2.0;
|
|
if (!neighborsVertex2)
|
|
{
|
|
Vertex org = neighotri.Org();
|
|
Vertex dest = neighotri.Dest();
|
|
Vertex apex = neighotri.Apex();
|
|
Point point5 = predicates.FindCircumcenter(org, dest, apex, ref xi2, ref eta2);
|
|
double num63 = point4.y - point2.y;
|
|
double num64 = point2.x - point4.x;
|
|
num63 = point.x + num63;
|
|
num64 = point.y + num64;
|
|
CircleLineIntersection(point.x, point.y, num63, num64, num43, num44, num32, ref p);
|
|
double num65;
|
|
double num66;
|
|
if (ChooseCorrectPoint(num72, num73, p[3], p[4], point.x, point.y, isObtuse: false))
|
|
{
|
|
num65 = p[3];
|
|
num66 = p[4];
|
|
}
|
|
else
|
|
{
|
|
num65 = p[1];
|
|
num66 = p[2];
|
|
}
|
|
double x = point4.x;
|
|
double y = point4.y;
|
|
num48 = point3.x - point4.x;
|
|
num49 = point3.y - point4.y;
|
|
double x2 = num59;
|
|
double y2 = num60;
|
|
LineLineIntersection(point.x, point.y, num63, num64, x, y, x2, y2, ref p3);
|
|
if (p3[0] > 0.0)
|
|
{
|
|
num14 = p3[1];
|
|
num15 = p3[2];
|
|
}
|
|
PointBetweenPoints(num65, num66, point.x, point.y, point5.x, point5.y, ref p2);
|
|
if (p[0] > 0.0)
|
|
{
|
|
if (Math.Abs(p2[0] - 1.0) <= 1E-50)
|
|
{
|
|
PointBetweenPoints(p2[2], p2[3], point.x, point.y, num14, num15, ref p4);
|
|
if (Math.Abs(p4[0] - 1.0) <= 1E-50 && p3[0] > 0.0)
|
|
{
|
|
if ((point2.x - num59) * (point2.x - num59) + (point2.y - num60) * (point2.y - num60) > num9 * ((point2.x - num14) * (point2.x - num14) + (point2.y - num15) * (point2.y - num15)) && IsBadTriangleAngle(point3.x, point3.y, point4.x, point4.y, num59, num60) && MinDistanceToNeighbor(num59, num60, ref neighotri) > MinDistanceToNeighbor(num14, num15, ref neighotri))
|
|
{
|
|
num70 = num59 - torg.x;
|
|
num71 = num60 - torg.y;
|
|
}
|
|
else if (IsBadTriangleAngle(point3.x, point3.y, point4.x, point4.y, num14, num15))
|
|
{
|
|
double num67 = Math.Sqrt((num14 - point.x) * (num14 - point.x) + (num15 - point.y) * (num15 - point.y));
|
|
double num68 = point.x - num14;
|
|
double num69 = point.y - num15;
|
|
num68 /= num67;
|
|
num69 /= num67;
|
|
num14 += num68 * num8 * Math.Sqrt(num3);
|
|
num15 += num69 * num8 * Math.Sqrt(num3);
|
|
if (IsBadTriangleAngle(point3.x, point3.y, point4.x, point4.y, num14, num15))
|
|
{
|
|
num70 = num26;
|
|
num71 = num27;
|
|
}
|
|
else
|
|
{
|
|
num70 = num14 - torg.x;
|
|
num71 = num15 - torg.y;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
num70 = p4[2] - torg.x;
|
|
num71 = p4[3] - torg.y;
|
|
}
|
|
}
|
|
else if (IsBadTriangleAngle(point3.x, point3.y, point4.x, point4.y, point5.x, point5.y))
|
|
{
|
|
num70 = num26;
|
|
num71 = num27;
|
|
}
|
|
else
|
|
{
|
|
num70 = p2[2] - torg.x;
|
|
num71 = p2[3] - torg.y;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
PointBetweenPoints(num65, num66, point.x, point.y, num14, num15, ref p4);
|
|
if (Math.Abs(p4[0] - 1.0) <= 1E-50 && p3[0] > 0.0)
|
|
{
|
|
if ((point2.x - num59) * (point2.x - num59) + (point2.y - num60) * (point2.y - num60) > num9 * ((point2.x - num14) * (point2.x - num14) + (point2.y - num15) * (point2.y - num15)) && IsBadTriangleAngle(point3.x, point3.y, point4.x, point4.y, num59, num60) && MinDistanceToNeighbor(num59, num60, ref neighotri) > MinDistanceToNeighbor(num14, num15, ref neighotri))
|
|
{
|
|
num70 = num59 - torg.x;
|
|
num71 = num60 - torg.y;
|
|
}
|
|
else if (IsBadTriangleAngle(point4.x, point4.y, point3.x, point3.y, num14, num15))
|
|
{
|
|
double num67 = Math.Sqrt((num14 - point.x) * (num14 - point.x) + (num15 - point.y) * (num15 - point.y));
|
|
double num68 = point.x - num14;
|
|
double num69 = point.y - num15;
|
|
num68 /= num67;
|
|
num69 /= num67;
|
|
num14 += num68 * num8 * Math.Sqrt(num3);
|
|
num15 += num69 * num8 * Math.Sqrt(num3);
|
|
if (IsBadTriangleAngle(point3.x, point3.y, point4.x, point4.y, num14, num15))
|
|
{
|
|
num70 = num26;
|
|
num71 = num27;
|
|
}
|
|
else
|
|
{
|
|
num70 = num14 - torg.x;
|
|
num71 = num15 - torg.y;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
num70 = p4[2] - torg.x;
|
|
num71 = p4[3] - torg.y;
|
|
}
|
|
}
|
|
else if (IsBadTriangleAngle(point3.x, point3.y, point4.x, point4.y, num65, num66))
|
|
{
|
|
double num67 = Math.Sqrt((num65 - point.x) * (num65 - point.x) + (num66 - point.y) * (num66 - point.y));
|
|
double num68 = point.x - num65;
|
|
double num69 = point.y - num66;
|
|
num68 /= num67;
|
|
num69 /= num67;
|
|
num65 += num68 * num8 * Math.Sqrt(num3);
|
|
num66 += num69 * num8 * Math.Sqrt(num3);
|
|
if (IsBadTriangleAngle(point3.x, point3.y, point4.x, point4.y, num65, num66))
|
|
{
|
|
num70 = num26;
|
|
num71 = num27;
|
|
}
|
|
else
|
|
{
|
|
num70 = num65 - torg.x;
|
|
num71 = num66 - torg.y;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
num70 = num65 - torg.x;
|
|
num71 = num66 - torg.y;
|
|
}
|
|
}
|
|
if ((point2.x - point.x) * (point2.x - point.x) + (point2.y - point.y) * (point2.y - point.y) > num9 * ((point2.x - (num70 + torg.x)) * (point2.x - (num70 + torg.x)) + (point2.y - (num71 + torg.y)) * (point2.y - (num71 + torg.y))))
|
|
{
|
|
num70 = num26;
|
|
num71 = num27;
|
|
}
|
|
}
|
|
}
|
|
if (flag)
|
|
{
|
|
if (neighborsVertex && neighborsVertex2)
|
|
{
|
|
if (num10 * ((point2.x - num72) * (point2.x - num72) + (point2.y - num73) * (point2.y - num73)) > (point2.x - num61) * (point2.x - num61) + (point2.y - num62) * (point2.y - num62))
|
|
{
|
|
num26 = num70;
|
|
num27 = num71;
|
|
}
|
|
else
|
|
{
|
|
num26 = num45;
|
|
num27 = num46;
|
|
}
|
|
}
|
|
else if (neighborsVertex)
|
|
{
|
|
if (num10 * ((point2.x - (num70 + torg.x)) * (point2.x - (num70 + torg.x)) + (point2.y - (num71 + torg.y)) * (point2.y - (num71 + torg.y))) > (point2.x - num61) * (point2.x - num61) + (point2.y - num62) * (point2.y - num62))
|
|
{
|
|
num26 = num70;
|
|
num27 = num71;
|
|
}
|
|
else
|
|
{
|
|
num26 = num45;
|
|
num27 = num46;
|
|
}
|
|
}
|
|
else if (neighborsVertex2)
|
|
{
|
|
if (num10 * ((point2.x - num72) * (point2.x - num72) + (point2.y - num73) * (point2.y - num73)) > (point2.x - (num45 + torg.x)) * (point2.x - (num45 + torg.x)) + (point2.y - (num46 + torg.y)) * (point2.y - (num46 + torg.y)))
|
|
{
|
|
num26 = num70;
|
|
num27 = num71;
|
|
}
|
|
else
|
|
{
|
|
num26 = num45;
|
|
num27 = num46;
|
|
}
|
|
}
|
|
else if (num10 * ((point2.x - (num70 + torg.x)) * (point2.x - (num70 + torg.x)) + (point2.y - (num71 + torg.y)) * (point2.y - (num71 + torg.y))) > (point2.x - (num45 + torg.x)) * (point2.x - (num45 + torg.x)) + (point2.y - (num46 + torg.y)) * (point2.y - (num46 + torg.y)))
|
|
{
|
|
num26 = num70;
|
|
num27 = num71;
|
|
}
|
|
else
|
|
{
|
|
num26 = num45;
|
|
num27 = num46;
|
|
}
|
|
}
|
|
else if (neighborsVertex && neighborsVertex2)
|
|
{
|
|
if (num10 * ((point2.x - num72) * (point2.x - num72) + (point2.y - num73) * (point2.y - num73)) > (point2.x - num61) * (point2.x - num61) + (point2.y - num62) * (point2.y - num62))
|
|
{
|
|
num26 = num70;
|
|
num27 = num71;
|
|
}
|
|
else
|
|
{
|
|
num26 = num45;
|
|
num27 = num46;
|
|
}
|
|
}
|
|
else if (neighborsVertex)
|
|
{
|
|
if (num10 * ((point2.x - (num70 + torg.x)) * (point2.x - (num70 + torg.x)) + (point2.y - (num71 + torg.y)) * (point2.y - (num71 + torg.y))) > (point2.x - num61) * (point2.x - num61) + (point2.y - num62) * (point2.y - num62))
|
|
{
|
|
num26 = num70;
|
|
num27 = num71;
|
|
}
|
|
else
|
|
{
|
|
num26 = num45;
|
|
num27 = num46;
|
|
}
|
|
}
|
|
else if (neighborsVertex2)
|
|
{
|
|
if (num10 * ((point2.x - num72) * (point2.x - num72) + (point2.y - num73) * (point2.y - num73)) > (point2.x - (num45 + torg.x)) * (point2.x - (num45 + torg.x)) + (point2.y - (num46 + torg.y)) * (point2.y - (num46 + torg.y)))
|
|
{
|
|
num26 = num70;
|
|
num27 = num71;
|
|
}
|
|
else
|
|
{
|
|
num26 = num45;
|
|
num27 = num46;
|
|
}
|
|
}
|
|
else if (num10 * ((point2.x - (num70 + torg.x)) * (point2.x - (num70 + torg.x)) + (point2.y - (num71 + torg.y)) * (point2.y - (num71 + torg.y))) > (point2.x - (num45 + torg.x)) * (point2.x - (num45 + torg.x)) + (point2.y - (num46 + torg.y)) * (point2.y - (num46 + torg.y)))
|
|
{
|
|
num26 = num70;
|
|
num27 = num71;
|
|
}
|
|
else
|
|
{
|
|
num26 = num45;
|
|
num27 = num46;
|
|
}
|
|
}
|
|
}
|
|
Point point6 = new Point();
|
|
if (num11 <= 0)
|
|
{
|
|
point6.x = torg.x + num26;
|
|
point6.y = torg.y + num27;
|
|
}
|
|
else
|
|
{
|
|
point6.x = num12 + num26;
|
|
point6.y = num13 + num27;
|
|
}
|
|
xi = (num19 * num26 - num18 * num27) * (2.0 * num25);
|
|
eta = (num16 * num27 - num17 * num26) * (2.0 * num25);
|
|
return point6;
|
|
}
|
|
|
|
private int LongestShortestEdge(double aodist, double dadist, double dodist)
|
|
{
|
|
int num = 0;
|
|
int num2 = 0;
|
|
int num3 = 0;
|
|
if (dodist < aodist && dodist < dadist)
|
|
{
|
|
num2 = 3;
|
|
if (aodist < dadist)
|
|
{
|
|
num = 2;
|
|
num3 = 1;
|
|
}
|
|
else
|
|
{
|
|
num = 1;
|
|
num3 = 2;
|
|
}
|
|
}
|
|
else if (aodist < dadist)
|
|
{
|
|
num2 = 1;
|
|
if (dodist < dadist)
|
|
{
|
|
num = 2;
|
|
num3 = 3;
|
|
}
|
|
else
|
|
{
|
|
num = 3;
|
|
num3 = 2;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
num2 = 2;
|
|
if (aodist < dodist)
|
|
{
|
|
num = 3;
|
|
num3 = 1;
|
|
}
|
|
else
|
|
{
|
|
num = 1;
|
|
num3 = 3;
|
|
}
|
|
}
|
|
return num2 * 100 + num3 * 10 + num;
|
|
}
|
|
|
|
private int DoSmoothing(Otri badotri, Vertex torg, Vertex tdest, Vertex tapex, ref double[] newloc)
|
|
{
|
|
int num = 0;
|
|
int num2 = 0;
|
|
int num3 = 0;
|
|
double[] array = new double[6];
|
|
int num4 = 0;
|
|
int num5 = 0;
|
|
int num6 = 0;
|
|
int num7 = 0;
|
|
bool flag = false;
|
|
num = GetStarPoints(badotri, torg, tdest, tapex, 1, ref points_p);
|
|
if (torg.type == VertexType.FreeVertex && num != 0 && ValidPolygonAngles(num, points_p) && ((behavior.MaxAngle != 0.0) ? GetWedgeIntersection(num, points_p, ref newloc) : GetWedgeIntersectionWithoutMaxAngle(num, points_p, ref newloc)))
|
|
{
|
|
array[0] = newloc[0];
|
|
array[1] = newloc[1];
|
|
num4++;
|
|
num5 = 1;
|
|
}
|
|
num2 = GetStarPoints(badotri, torg, tdest, tapex, 2, ref points_q);
|
|
if (tdest.type == VertexType.FreeVertex && num2 != 0 && ValidPolygonAngles(num2, points_q) && ((behavior.MaxAngle != 0.0) ? GetWedgeIntersection(num2, points_q, ref newloc) : GetWedgeIntersectionWithoutMaxAngle(num2, points_q, ref newloc)))
|
|
{
|
|
array[2] = newloc[0];
|
|
array[3] = newloc[1];
|
|
num4++;
|
|
num6 = 2;
|
|
}
|
|
num3 = GetStarPoints(badotri, torg, tdest, tapex, 3, ref points_r);
|
|
if (tapex.type == VertexType.FreeVertex && num3 != 0 && ValidPolygonAngles(num3, points_r) && ((behavior.MaxAngle != 0.0) ? GetWedgeIntersection(num3, points_r, ref newloc) : GetWedgeIntersectionWithoutMaxAngle(num3, points_r, ref newloc)))
|
|
{
|
|
array[4] = newloc[0];
|
|
array[5] = newloc[1];
|
|
num4++;
|
|
num7 = 3;
|
|
}
|
|
if (num4 > 0)
|
|
{
|
|
if (num5 > 0)
|
|
{
|
|
newloc[0] = array[0];
|
|
newloc[1] = array[1];
|
|
return num5;
|
|
}
|
|
if (num6 > 0)
|
|
{
|
|
newloc[0] = array[2];
|
|
newloc[1] = array[3];
|
|
return num6;
|
|
}
|
|
if (num7 > 0)
|
|
{
|
|
newloc[0] = array[4];
|
|
newloc[1] = array[5];
|
|
return num7;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
private int GetStarPoints(Otri badotri, Vertex p, Vertex q, Vertex r, int whichPoint, ref double[] points)
|
|
{
|
|
Otri neighotri = default(Otri);
|
|
double first_x = 0.0;
|
|
double first_y = 0.0;
|
|
double num = 0.0;
|
|
double num2 = 0.0;
|
|
double num3 = 0.0;
|
|
double num4 = 0.0;
|
|
double[] thirdpoint = new double[2];
|
|
int num5 = 0;
|
|
switch (whichPoint)
|
|
{
|
|
case 1:
|
|
first_x = p.x;
|
|
first_y = p.y;
|
|
num = r.x;
|
|
num2 = r.y;
|
|
num3 = q.x;
|
|
num4 = q.y;
|
|
break;
|
|
case 2:
|
|
first_x = q.x;
|
|
first_y = q.y;
|
|
num = p.x;
|
|
num2 = p.y;
|
|
num3 = r.x;
|
|
num4 = r.y;
|
|
break;
|
|
case 3:
|
|
first_x = r.x;
|
|
first_y = r.y;
|
|
num = q.x;
|
|
num2 = q.y;
|
|
num3 = p.x;
|
|
num4 = p.y;
|
|
break;
|
|
}
|
|
Otri badotri2 = badotri;
|
|
points[num5] = num;
|
|
num5++;
|
|
points[num5] = num2;
|
|
num5++;
|
|
thirdpoint[0] = num;
|
|
thirdpoint[1] = num2;
|
|
do
|
|
{
|
|
if (!GetNeighborsVertex(badotri2, first_x, first_y, num, num2, ref thirdpoint, ref neighotri))
|
|
{
|
|
badotri2 = neighotri;
|
|
num = thirdpoint[0];
|
|
num2 = thirdpoint[1];
|
|
points[num5] = thirdpoint[0];
|
|
num5++;
|
|
points[num5] = thirdpoint[1];
|
|
num5++;
|
|
continue;
|
|
}
|
|
num5 = 0;
|
|
break;
|
|
}
|
|
while (!(Math.Abs(thirdpoint[0] - num3) <= 1E-50) || !(Math.Abs(thirdpoint[1] - num4) <= 1E-50));
|
|
return num5 / 2;
|
|
}
|
|
|
|
private bool GetNeighborsVertex(Otri badotri, double first_x, double first_y, double second_x, double second_y, ref double[] thirdpoint, ref Otri neighotri)
|
|
{
|
|
Otri ot = default(Otri);
|
|
bool result = false;
|
|
Vertex vertex = null;
|
|
Vertex vertex2 = null;
|
|
Vertex vertex3 = null;
|
|
int num = 0;
|
|
int num2 = 0;
|
|
badotri.orient = 0;
|
|
while (badotri.orient < 3)
|
|
{
|
|
badotri.Sym(ref ot);
|
|
if (ot.tri.id != -1)
|
|
{
|
|
vertex = ot.Org();
|
|
vertex2 = ot.Dest();
|
|
vertex3 = ot.Apex();
|
|
if ((vertex.x != vertex2.x || vertex.y != vertex2.y) && (vertex2.x != vertex3.x || vertex2.y != vertex3.y) && (vertex.x != vertex3.x || vertex.y != vertex3.y))
|
|
{
|
|
num = 0;
|
|
if (Math.Abs(first_x - vertex.x) < 1E-50 && Math.Abs(first_y - vertex.y) < 1E-50)
|
|
{
|
|
num = 11;
|
|
}
|
|
else if (Math.Abs(first_x - vertex2.x) < 1E-50 && Math.Abs(first_y - vertex2.y) < 1E-50)
|
|
{
|
|
num = 12;
|
|
}
|
|
else if (Math.Abs(first_x - vertex3.x) < 1E-50 && Math.Abs(first_y - vertex3.y) < 1E-50)
|
|
{
|
|
num = 13;
|
|
}
|
|
num2 = 0;
|
|
if (Math.Abs(second_x - vertex.x) < 1E-50 && Math.Abs(second_y - vertex.y) < 1E-50)
|
|
{
|
|
num2 = 21;
|
|
}
|
|
else if (Math.Abs(second_x - vertex2.x) < 1E-50 && Math.Abs(second_y - vertex2.y) < 1E-50)
|
|
{
|
|
num2 = 22;
|
|
}
|
|
else if (Math.Abs(second_x - vertex3.x) < 1E-50 && Math.Abs(second_y - vertex3.y) < 1E-50)
|
|
{
|
|
num2 = 23;
|
|
}
|
|
}
|
|
}
|
|
if ((num == 11 && (num2 == 22 || num2 == 23)) || (num == 12 && (num2 == 21 || num2 == 23)) || (num == 13 && (num2 == 21 || num2 == 22)))
|
|
{
|
|
break;
|
|
}
|
|
badotri.orient++;
|
|
}
|
|
switch (num)
|
|
{
|
|
case 0:
|
|
result = true;
|
|
break;
|
|
case 11:
|
|
switch (num2)
|
|
{
|
|
case 22:
|
|
thirdpoint[0] = vertex3.x;
|
|
thirdpoint[1] = vertex3.y;
|
|
break;
|
|
case 23:
|
|
thirdpoint[0] = vertex2.x;
|
|
thirdpoint[1] = vertex2.y;
|
|
break;
|
|
default:
|
|
result = true;
|
|
break;
|
|
}
|
|
break;
|
|
case 12:
|
|
switch (num2)
|
|
{
|
|
case 21:
|
|
thirdpoint[0] = vertex3.x;
|
|
thirdpoint[1] = vertex3.y;
|
|
break;
|
|
case 23:
|
|
thirdpoint[0] = vertex.x;
|
|
thirdpoint[1] = vertex.y;
|
|
break;
|
|
default:
|
|
result = true;
|
|
break;
|
|
}
|
|
break;
|
|
case 13:
|
|
switch (num2)
|
|
{
|
|
case 21:
|
|
thirdpoint[0] = vertex2.x;
|
|
thirdpoint[1] = vertex2.y;
|
|
break;
|
|
case 22:
|
|
thirdpoint[0] = vertex.x;
|
|
thirdpoint[1] = vertex.y;
|
|
break;
|
|
default:
|
|
result = true;
|
|
break;
|
|
}
|
|
break;
|
|
default:
|
|
if (num2 == 0)
|
|
{
|
|
result = true;
|
|
}
|
|
break;
|
|
}
|
|
neighotri = ot;
|
|
return result;
|
|
}
|
|
|
|
private bool GetWedgeIntersectionWithoutMaxAngle(int numpoints, double[] points, ref double[] newloc)
|
|
{
|
|
if (2 * numpoints > petalx.Length)
|
|
{
|
|
petalx = new double[2 * numpoints];
|
|
petaly = new double[2 * numpoints];
|
|
petalr = new double[2 * numpoints];
|
|
wedges = new double[2 * numpoints * 16 + 36];
|
|
}
|
|
double[] p = new double[3];
|
|
int num = 0;
|
|
double num2 = points[2 * numpoints - 4];
|
|
double num3 = points[2 * numpoints - 3];
|
|
double num4 = points[2 * numpoints - 2];
|
|
double num5 = points[2 * numpoints - 1];
|
|
double num6 = behavior.MinAngle * Math.PI / 180.0;
|
|
double num7;
|
|
double num8;
|
|
if (behavior.goodAngle == 1.0)
|
|
{
|
|
num7 = 0.0;
|
|
num8 = 0.0;
|
|
}
|
|
else
|
|
{
|
|
num7 = 0.5 / Math.Tan(num6);
|
|
num8 = 0.5 / Math.Sin(num6);
|
|
}
|
|
for (int i = 0; i < numpoints * 2; i += 2)
|
|
{
|
|
double num9 = points[i];
|
|
double num10 = points[i + 1];
|
|
double num11 = num4 - num2;
|
|
double num12 = num5 - num3;
|
|
double num13 = Math.Sqrt(num11 * num11 + num12 * num12);
|
|
petalx[i / 2] = num2 + 0.5 * num11 - num7 * num12;
|
|
petaly[i / 2] = num3 + 0.5 * num12 + num7 * num11;
|
|
petalr[i / 2] = num8 * num13;
|
|
petalx[numpoints + i / 2] = petalx[i / 2];
|
|
petaly[numpoints + i / 2] = petaly[i / 2];
|
|
petalr[numpoints + i / 2] = petalr[i / 2];
|
|
double num14 = (num2 + num4) / 2.0;
|
|
double num15 = (num3 + num5) / 2.0;
|
|
double num16 = Math.Sqrt((petalx[i / 2] - num14) * (petalx[i / 2] - num14) + (petaly[i / 2] - num15) * (petaly[i / 2] - num15));
|
|
double num17 = (petalx[i / 2] - num14) / num16;
|
|
double num18 = (petaly[i / 2] - num15) / num16;
|
|
double num19 = petalx[i / 2] + num17 * petalr[i / 2];
|
|
double num20 = petaly[i / 2] + num18 * petalr[i / 2];
|
|
num17 = num4 - num2;
|
|
num18 = num5 - num3;
|
|
double num21 = num4 * Math.Cos(num6) - num5 * Math.Sin(num6) + num2 - num2 * Math.Cos(num6) + num3 * Math.Sin(num6);
|
|
double num22 = num4 * Math.Sin(num6) + num5 * Math.Cos(num6) + num3 - num2 * Math.Sin(num6) - num3 * Math.Cos(num6);
|
|
wedges[i * 16] = num2;
|
|
wedges[i * 16 + 1] = num3;
|
|
wedges[i * 16 + 2] = num21;
|
|
wedges[i * 16 + 3] = num22;
|
|
num17 = num2 - num4;
|
|
num18 = num3 - num5;
|
|
double num23 = num2 * Math.Cos(num6) + num3 * Math.Sin(num6) + num4 - num4 * Math.Cos(num6) - num5 * Math.Sin(num6);
|
|
double num24 = (0.0 - num2) * Math.Sin(num6) + num3 * Math.Cos(num6) + num5 + num4 * Math.Sin(num6) - num5 * Math.Cos(num6);
|
|
wedges[i * 16 + 4] = num23;
|
|
wedges[i * 16 + 5] = num24;
|
|
wedges[i * 16 + 6] = num4;
|
|
wedges[i * 16 + 7] = num5;
|
|
num17 = num19 - petalx[i / 2];
|
|
num18 = num20 - petaly[i / 2];
|
|
double num25 = num19;
|
|
double num26 = num20;
|
|
for (int j = 1; j < 4; j++)
|
|
{
|
|
double num27 = num19 * Math.Cos((Math.PI / 3.0 - num6) * (double)j) + num20 * Math.Sin((Math.PI / 3.0 - num6) * (double)j) + petalx[i / 2] - petalx[i / 2] * Math.Cos((Math.PI / 3.0 - num6) * (double)j) - petaly[i / 2] * Math.Sin((Math.PI / 3.0 - num6) * (double)j);
|
|
double num28 = (0.0 - num19) * Math.Sin((Math.PI / 3.0 - num6) * (double)j) + num20 * Math.Cos((Math.PI / 3.0 - num6) * (double)j) + petaly[i / 2] + petalx[i / 2] * Math.Sin((Math.PI / 3.0 - num6) * (double)j) - petaly[i / 2] * Math.Cos((Math.PI / 3.0 - num6) * (double)j);
|
|
wedges[i * 16 + 8 + 4 * (j - 1)] = num27;
|
|
wedges[i * 16 + 9 + 4 * (j - 1)] = num28;
|
|
wedges[i * 16 + 10 + 4 * (j - 1)] = num25;
|
|
wedges[i * 16 + 11 + 4 * (j - 1)] = num26;
|
|
num25 = num27;
|
|
num26 = num28;
|
|
}
|
|
num25 = num19;
|
|
num26 = num20;
|
|
for (int j = 1; j < 4; j++)
|
|
{
|
|
double num29 = num19 * Math.Cos((Math.PI / 3.0 - num6) * (double)j) - num20 * Math.Sin((Math.PI / 3.0 - num6) * (double)j) + petalx[i / 2] - petalx[i / 2] * Math.Cos((Math.PI / 3.0 - num6) * (double)j) + petaly[i / 2] * Math.Sin((Math.PI / 3.0 - num6) * (double)j);
|
|
double num30 = num19 * Math.Sin((Math.PI / 3.0 - num6) * (double)j) + num20 * Math.Cos((Math.PI / 3.0 - num6) * (double)j) + petaly[i / 2] - petalx[i / 2] * Math.Sin((Math.PI / 3.0 - num6) * (double)j) - petaly[i / 2] * Math.Cos((Math.PI / 3.0 - num6) * (double)j);
|
|
wedges[i * 16 + 20 + 4 * (j - 1)] = num25;
|
|
wedges[i * 16 + 21 + 4 * (j - 1)] = num26;
|
|
wedges[i * 16 + 22 + 4 * (j - 1)] = num29;
|
|
wedges[i * 16 + 23 + 4 * (j - 1)] = num30;
|
|
num25 = num29;
|
|
num26 = num30;
|
|
}
|
|
if (i == 0)
|
|
{
|
|
LineLineIntersection(num2, num3, num21, num22, num4, num5, num23, num24, ref p);
|
|
if (p[0] == 1.0)
|
|
{
|
|
initialConvexPoly[0] = p[1];
|
|
initialConvexPoly[1] = p[2];
|
|
initialConvexPoly[2] = wedges[i * 16 + 16];
|
|
initialConvexPoly[3] = wedges[i * 16 + 17];
|
|
initialConvexPoly[4] = wedges[i * 16 + 12];
|
|
initialConvexPoly[5] = wedges[i * 16 + 13];
|
|
initialConvexPoly[6] = wedges[i * 16 + 8];
|
|
initialConvexPoly[7] = wedges[i * 16 + 9];
|
|
initialConvexPoly[8] = num19;
|
|
initialConvexPoly[9] = num20;
|
|
initialConvexPoly[10] = wedges[i * 16 + 22];
|
|
initialConvexPoly[11] = wedges[i * 16 + 23];
|
|
initialConvexPoly[12] = wedges[i * 16 + 26];
|
|
initialConvexPoly[13] = wedges[i * 16 + 27];
|
|
initialConvexPoly[14] = wedges[i * 16 + 30];
|
|
initialConvexPoly[15] = wedges[i * 16 + 31];
|
|
}
|
|
}
|
|
num2 = num4;
|
|
num3 = num5;
|
|
num4 = num9;
|
|
num5 = num10;
|
|
}
|
|
if (numpoints != 0)
|
|
{
|
|
int num31 = (numpoints - 1) / 2 + 1;
|
|
int num32 = 0;
|
|
int num33 = 0;
|
|
int i = 1;
|
|
int numvertices = 8;
|
|
for (int j = 0; j < 32; j += 4)
|
|
{
|
|
num = HalfPlaneIntersection(numvertices, ref initialConvexPoly, wedges[32 * num31 + j], wedges[32 * num31 + 1 + j], wedges[32 * num31 + 2 + j], wedges[32 * num31 + 3 + j]);
|
|
if (num == 0)
|
|
{
|
|
return false;
|
|
}
|
|
numvertices = num;
|
|
}
|
|
for (num33++; num33 < numpoints - 1; num33++)
|
|
{
|
|
for (int j = 0; j < 32; j += 4)
|
|
{
|
|
num = HalfPlaneIntersection(numvertices, ref initialConvexPoly, wedges[32 * (i + num31 * num32) + j], wedges[32 * (i + num31 * num32) + 1 + j], wedges[32 * (i + num31 * num32) + 2 + j], wedges[32 * (i + num31 * num32) + 3 + j]);
|
|
if (num == 0)
|
|
{
|
|
return false;
|
|
}
|
|
numvertices = num;
|
|
}
|
|
i += num32;
|
|
num32 = (num32 + 1) % 2;
|
|
}
|
|
FindPolyCentroid(num, initialConvexPoly, ref newloc);
|
|
if (!behavior.fixedArea)
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
private bool GetWedgeIntersection(int numpoints, double[] points, ref double[] newloc)
|
|
{
|
|
if (2 * numpoints > petalx.Length)
|
|
{
|
|
petalx = new double[2 * numpoints];
|
|
petaly = new double[2 * numpoints];
|
|
petalr = new double[2 * numpoints];
|
|
wedges = new double[2 * numpoints * 20 + 40];
|
|
}
|
|
double[] p = new double[3];
|
|
double[] p2 = new double[3];
|
|
double[] p3 = new double[3];
|
|
double[] p4 = new double[3];
|
|
int num = 0;
|
|
int num2 = 0;
|
|
double num3 = 4.0;
|
|
double num4 = 4.0;
|
|
double num5 = points[2 * numpoints - 4];
|
|
double num6 = points[2 * numpoints - 3];
|
|
double num7 = points[2 * numpoints - 2];
|
|
double num8 = points[2 * numpoints - 1];
|
|
double num9 = behavior.MinAngle * Math.PI / 180.0;
|
|
double num10 = Math.Sin(num9);
|
|
double num11 = Math.Cos(num9);
|
|
double num12 = behavior.MaxAngle * Math.PI / 180.0;
|
|
double num13 = Math.Sin(num12);
|
|
double num14 = Math.Cos(num12);
|
|
double num15;
|
|
double num16;
|
|
if (behavior.goodAngle == 1.0)
|
|
{
|
|
num15 = 0.0;
|
|
num16 = 0.0;
|
|
}
|
|
else
|
|
{
|
|
num15 = 0.5 / Math.Tan(num9);
|
|
num16 = 0.5 / Math.Sin(num9);
|
|
}
|
|
for (int i = 0; i < numpoints * 2; i += 2)
|
|
{
|
|
double num17 = points[i];
|
|
double num18 = points[i + 1];
|
|
double num19 = num7 - num5;
|
|
double num20 = num8 - num6;
|
|
double num21 = Math.Sqrt(num19 * num19 + num20 * num20);
|
|
petalx[i / 2] = num5 + 0.5 * num19 - num15 * num20;
|
|
petaly[i / 2] = num6 + 0.5 * num20 + num15 * num19;
|
|
petalr[i / 2] = num16 * num21;
|
|
petalx[numpoints + i / 2] = petalx[i / 2];
|
|
petaly[numpoints + i / 2] = petaly[i / 2];
|
|
petalr[numpoints + i / 2] = petalr[i / 2];
|
|
double num22 = (num5 + num7) / 2.0;
|
|
double num23 = (num6 + num8) / 2.0;
|
|
double num24 = Math.Sqrt((petalx[i / 2] - num22) * (petalx[i / 2] - num22) + (petaly[i / 2] - num23) * (petaly[i / 2] - num23));
|
|
double num25 = (petalx[i / 2] - num22) / num24;
|
|
double num26 = (petaly[i / 2] - num23) / num24;
|
|
double num27 = petalx[i / 2] + num25 * petalr[i / 2];
|
|
double num28 = petaly[i / 2] + num26 * petalr[i / 2];
|
|
num25 = num7 - num5;
|
|
num26 = num8 - num6;
|
|
double num29 = num7 * num11 - num8 * num10 + num5 - num5 * num11 + num6 * num10;
|
|
double num30 = num7 * num10 + num8 * num11 + num6 - num5 * num10 - num6 * num11;
|
|
wedges[i * 20] = num5;
|
|
wedges[i * 20 + 1] = num6;
|
|
wedges[i * 20 + 2] = num29;
|
|
wedges[i * 20 + 3] = num30;
|
|
num25 = num5 - num7;
|
|
num26 = num6 - num8;
|
|
double num31 = num5 * num11 + num6 * num10 + num7 - num7 * num11 - num8 * num10;
|
|
double num32 = (0.0 - num5) * num10 + num6 * num11 + num8 + num7 * num10 - num8 * num11;
|
|
wedges[i * 20 + 4] = num31;
|
|
wedges[i * 20 + 5] = num32;
|
|
wedges[i * 20 + 6] = num7;
|
|
wedges[i * 20 + 7] = num8;
|
|
num25 = num27 - petalx[i / 2];
|
|
num26 = num28 - petaly[i / 2];
|
|
double num33 = num27;
|
|
double num34 = num28;
|
|
num9 = 2.0 * behavior.MaxAngle + behavior.MinAngle - 180.0;
|
|
if (num9 <= 0.0)
|
|
{
|
|
num2 = 4;
|
|
num3 = 1.0;
|
|
num4 = 1.0;
|
|
}
|
|
else if (num9 <= 5.0)
|
|
{
|
|
num2 = 6;
|
|
num3 = 2.0;
|
|
num4 = 2.0;
|
|
}
|
|
else if (num9 <= 10.0)
|
|
{
|
|
num2 = 8;
|
|
num3 = 3.0;
|
|
num4 = 3.0;
|
|
}
|
|
else
|
|
{
|
|
num2 = 10;
|
|
num3 = 4.0;
|
|
num4 = 4.0;
|
|
}
|
|
num9 = num9 * Math.PI / 180.0;
|
|
for (int j = 1; (double)j < num3; j++)
|
|
{
|
|
if (num3 != 1.0)
|
|
{
|
|
double num35 = num27 * Math.Cos(num9 / (num3 - 1.0) * (double)j) + num28 * Math.Sin(num9 / (num3 - 1.0) * (double)j) + petalx[i / 2] - petalx[i / 2] * Math.Cos(num9 / (num3 - 1.0) * (double)j) - petaly[i / 2] * Math.Sin(num9 / (num3 - 1.0) * (double)j);
|
|
double num36 = (0.0 - num27) * Math.Sin(num9 / (num3 - 1.0) * (double)j) + num28 * Math.Cos(num9 / (num3 - 1.0) * (double)j) + petaly[i / 2] + petalx[i / 2] * Math.Sin(num9 / (num3 - 1.0) * (double)j) - petaly[i / 2] * Math.Cos(num9 / (num3 - 1.0) * (double)j);
|
|
wedges[i * 20 + 8 + 4 * (j - 1)] = num35;
|
|
wedges[i * 20 + 9 + 4 * (j - 1)] = num36;
|
|
wedges[i * 20 + 10 + 4 * (j - 1)] = num33;
|
|
wedges[i * 20 + 11 + 4 * (j - 1)] = num34;
|
|
num33 = num35;
|
|
num34 = num36;
|
|
}
|
|
}
|
|
num25 = num5 - num7;
|
|
num26 = num6 - num8;
|
|
double num37 = num5 * num14 + num6 * num13 + num7 - num7 * num14 - num8 * num13;
|
|
double num38 = (0.0 - num5) * num13 + num6 * num14 + num8 + num7 * num13 - num8 * num14;
|
|
wedges[i * 20 + 20] = num7;
|
|
wedges[i * 20 + 21] = num8;
|
|
wedges[i * 20 + 22] = num37;
|
|
wedges[i * 20 + 23] = num38;
|
|
num33 = num27;
|
|
num34 = num28;
|
|
for (int j = 1; (double)j < num4; j++)
|
|
{
|
|
if (num4 != 1.0)
|
|
{
|
|
double num39 = num27 * Math.Cos(num9 / (num4 - 1.0) * (double)j) - num28 * Math.Sin(num9 / (num4 - 1.0) * (double)j) + petalx[i / 2] - petalx[i / 2] * Math.Cos(num9 / (num4 - 1.0) * (double)j) + petaly[i / 2] * Math.Sin(num9 / (num4 - 1.0) * (double)j);
|
|
double num40 = num27 * Math.Sin(num9 / (num4 - 1.0) * (double)j) + num28 * Math.Cos(num9 / (num4 - 1.0) * (double)j) + petaly[i / 2] - petalx[i / 2] * Math.Sin(num9 / (num4 - 1.0) * (double)j) - petaly[i / 2] * Math.Cos(num9 / (num4 - 1.0) * (double)j);
|
|
wedges[i * 20 + 24 + 4 * (j - 1)] = num33;
|
|
wedges[i * 20 + 25 + 4 * (j - 1)] = num34;
|
|
wedges[i * 20 + 26 + 4 * (j - 1)] = num39;
|
|
wedges[i * 20 + 27 + 4 * (j - 1)] = num40;
|
|
num33 = num39;
|
|
num34 = num40;
|
|
}
|
|
}
|
|
num25 = num7 - num5;
|
|
num26 = num8 - num6;
|
|
double num41 = num7 * num14 - num8 * num13 + num5 - num5 * num14 + num6 * num13;
|
|
double num42 = num7 * num13 + num8 * num14 + num6 - num5 * num13 - num6 * num14;
|
|
wedges[i * 20 + 36] = num41;
|
|
wedges[i * 20 + 37] = num42;
|
|
wedges[i * 20 + 38] = num5;
|
|
wedges[i * 20 + 39] = num6;
|
|
if (i == 0)
|
|
{
|
|
switch (num2)
|
|
{
|
|
case 4:
|
|
LineLineIntersection(num5, num6, num29, num30, num7, num8, num31, num32, ref p);
|
|
LineLineIntersection(num5, num6, num29, num30, num7, num8, num37, num38, ref p2);
|
|
LineLineIntersection(num5, num6, num41, num42, num7, num8, num37, num38, ref p3);
|
|
LineLineIntersection(num5, num6, num41, num42, num7, num8, num31, num32, ref p4);
|
|
if (p[0] == 1.0 && p2[0] == 1.0 && p3[0] == 1.0 && p4[0] == 1.0)
|
|
{
|
|
initialConvexPoly[0] = p[1];
|
|
initialConvexPoly[1] = p[2];
|
|
initialConvexPoly[2] = p2[1];
|
|
initialConvexPoly[3] = p2[2];
|
|
initialConvexPoly[4] = p3[1];
|
|
initialConvexPoly[5] = p3[2];
|
|
initialConvexPoly[6] = p4[1];
|
|
initialConvexPoly[7] = p4[2];
|
|
}
|
|
break;
|
|
case 6:
|
|
LineLineIntersection(num5, num6, num29, num30, num7, num8, num31, num32, ref p);
|
|
LineLineIntersection(num5, num6, num29, num30, num7, num8, num37, num38, ref p2);
|
|
LineLineIntersection(num5, num6, num41, num42, num7, num8, num31, num32, ref p3);
|
|
if (p[0] == 1.0 && p2[0] == 1.0 && p3[0] == 1.0)
|
|
{
|
|
initialConvexPoly[0] = p[1];
|
|
initialConvexPoly[1] = p[2];
|
|
initialConvexPoly[2] = p2[1];
|
|
initialConvexPoly[3] = p2[2];
|
|
initialConvexPoly[4] = wedges[i * 20 + 8];
|
|
initialConvexPoly[5] = wedges[i * 20 + 9];
|
|
initialConvexPoly[6] = num27;
|
|
initialConvexPoly[7] = num28;
|
|
initialConvexPoly[8] = wedges[i * 20 + 26];
|
|
initialConvexPoly[9] = wedges[i * 20 + 27];
|
|
initialConvexPoly[10] = p3[1];
|
|
initialConvexPoly[11] = p3[2];
|
|
}
|
|
break;
|
|
case 8:
|
|
LineLineIntersection(num5, num6, num29, num30, num7, num8, num31, num32, ref p);
|
|
LineLineIntersection(num5, num6, num29, num30, num7, num8, num37, num38, ref p2);
|
|
LineLineIntersection(num5, num6, num41, num42, num7, num8, num31, num32, ref p3);
|
|
if (p[0] == 1.0 && p2[0] == 1.0 && p3[0] == 1.0)
|
|
{
|
|
initialConvexPoly[0] = p[1];
|
|
initialConvexPoly[1] = p[2];
|
|
initialConvexPoly[2] = p2[1];
|
|
initialConvexPoly[3] = p2[2];
|
|
initialConvexPoly[4] = wedges[i * 20 + 12];
|
|
initialConvexPoly[5] = wedges[i * 20 + 13];
|
|
initialConvexPoly[6] = wedges[i * 20 + 8];
|
|
initialConvexPoly[7] = wedges[i * 20 + 9];
|
|
initialConvexPoly[8] = num27;
|
|
initialConvexPoly[9] = num28;
|
|
initialConvexPoly[10] = wedges[i * 20 + 26];
|
|
initialConvexPoly[11] = wedges[i * 20 + 27];
|
|
initialConvexPoly[12] = wedges[i * 20 + 30];
|
|
initialConvexPoly[13] = wedges[i * 20 + 31];
|
|
initialConvexPoly[14] = p3[1];
|
|
initialConvexPoly[15] = p3[2];
|
|
}
|
|
break;
|
|
case 10:
|
|
LineLineIntersection(num5, num6, num29, num30, num7, num8, num31, num32, ref p);
|
|
LineLineIntersection(num5, num6, num29, num30, num7, num8, num37, num38, ref p2);
|
|
LineLineIntersection(num5, num6, num41, num42, num7, num8, num31, num32, ref p3);
|
|
if (p[0] == 1.0 && p2[0] == 1.0 && p3[0] == 1.0)
|
|
{
|
|
initialConvexPoly[0] = p[1];
|
|
initialConvexPoly[1] = p[2];
|
|
initialConvexPoly[2] = p2[1];
|
|
initialConvexPoly[3] = p2[2];
|
|
initialConvexPoly[4] = wedges[i * 20 + 16];
|
|
initialConvexPoly[5] = wedges[i * 20 + 17];
|
|
initialConvexPoly[6] = wedges[i * 20 + 12];
|
|
initialConvexPoly[7] = wedges[i * 20 + 13];
|
|
initialConvexPoly[8] = wedges[i * 20 + 8];
|
|
initialConvexPoly[9] = wedges[i * 20 + 9];
|
|
initialConvexPoly[10] = num27;
|
|
initialConvexPoly[11] = num28;
|
|
initialConvexPoly[12] = wedges[i * 20 + 28];
|
|
initialConvexPoly[13] = wedges[i * 20 + 29];
|
|
initialConvexPoly[14] = wedges[i * 20 + 32];
|
|
initialConvexPoly[15] = wedges[i * 20 + 33];
|
|
initialConvexPoly[16] = wedges[i * 20 + 34];
|
|
initialConvexPoly[17] = wedges[i * 20 + 35];
|
|
initialConvexPoly[18] = p3[1];
|
|
initialConvexPoly[19] = p3[2];
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
num5 = num7;
|
|
num6 = num8;
|
|
num7 = num17;
|
|
num8 = num18;
|
|
}
|
|
if (numpoints != 0)
|
|
{
|
|
int num43 = (numpoints - 1) / 2 + 1;
|
|
int num44 = 0;
|
|
int num45 = 0;
|
|
int i = 1;
|
|
int numvertices = num2;
|
|
for (int j = 0; j < 40; j += 4)
|
|
{
|
|
if ((num2 != 4 || (j != 8 && j != 12 && j != 16 && j != 24 && j != 28 && j != 32)) && (num2 != 6 || (j != 12 && j != 16 && j != 28 && j != 32)) && (num2 != 8 || (j != 16 && j != 32)))
|
|
{
|
|
num = HalfPlaneIntersection(numvertices, ref initialConvexPoly, wedges[40 * num43 + j], wedges[40 * num43 + 1 + j], wedges[40 * num43 + 2 + j], wedges[40 * num43 + 3 + j]);
|
|
if (num == 0)
|
|
{
|
|
return false;
|
|
}
|
|
numvertices = num;
|
|
}
|
|
}
|
|
for (num45++; num45 < numpoints - 1; num45++)
|
|
{
|
|
for (int j = 0; j < 40; j += 4)
|
|
{
|
|
if ((num2 != 4 || (j != 8 && j != 12 && j != 16 && j != 24 && j != 28 && j != 32)) && (num2 != 6 || (j != 12 && j != 16 && j != 28 && j != 32)) && (num2 != 8 || (j != 16 && j != 32)))
|
|
{
|
|
num = HalfPlaneIntersection(numvertices, ref initialConvexPoly, wedges[40 * (i + num43 * num44) + j], wedges[40 * (i + num43 * num44) + 1 + j], wedges[40 * (i + num43 * num44) + 2 + j], wedges[40 * (i + num43 * num44) + 3 + j]);
|
|
if (num == 0)
|
|
{
|
|
return false;
|
|
}
|
|
numvertices = num;
|
|
}
|
|
}
|
|
i += num44;
|
|
num44 = (num44 + 1) % 2;
|
|
}
|
|
FindPolyCentroid(num, initialConvexPoly, ref newloc);
|
|
if (behavior.MaxAngle == 0.0)
|
|
{
|
|
return true;
|
|
}
|
|
int num46 = 0;
|
|
for (int j = 0; j < numpoints * 2 - 2; j += 2)
|
|
{
|
|
if (IsBadTriangleAngle(newloc[0], newloc[1], points[j], points[j + 1], points[j + 2], points[j + 3]))
|
|
{
|
|
num46++;
|
|
}
|
|
}
|
|
if (IsBadTriangleAngle(newloc[0], newloc[1], points[0], points[1], points[numpoints * 2 - 2], points[numpoints * 2 - 1]))
|
|
{
|
|
num46++;
|
|
}
|
|
if (num46 == 0)
|
|
{
|
|
return true;
|
|
}
|
|
int num47 = ((numpoints <= 2) ? 20 : 30);
|
|
for (int k = 0; k < 2 * numpoints; k += 2)
|
|
{
|
|
for (int l = 1; l < num47; l++)
|
|
{
|
|
newloc[0] = 0.0;
|
|
newloc[1] = 0.0;
|
|
for (i = 0; i < 2 * numpoints; i += 2)
|
|
{
|
|
double num48 = 1.0 / (double)numpoints;
|
|
if (i == k)
|
|
{
|
|
newloc[0] = newloc[0] + 0.1 * (double)l * num48 * points[i];
|
|
newloc[1] = newloc[1] + 0.1 * (double)l * num48 * points[i + 1];
|
|
}
|
|
else
|
|
{
|
|
num48 = (1.0 - 0.1 * (double)l * num48) / ((double)numpoints - 1.0);
|
|
newloc[0] = newloc[0] + num48 * points[i];
|
|
newloc[1] = newloc[1] + num48 * points[i + 1];
|
|
}
|
|
}
|
|
num46 = 0;
|
|
for (int j = 0; j < numpoints * 2 - 2; j += 2)
|
|
{
|
|
if (IsBadTriangleAngle(newloc[0], newloc[1], points[j], points[j + 1], points[j + 2], points[j + 3]))
|
|
{
|
|
num46++;
|
|
}
|
|
}
|
|
if (IsBadTriangleAngle(newloc[0], newloc[1], points[0], points[1], points[numpoints * 2 - 2], points[numpoints * 2 - 1]))
|
|
{
|
|
num46++;
|
|
}
|
|
if (num46 == 0)
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
private bool ValidPolygonAngles(int numpoints, double[] points)
|
|
{
|
|
for (int i = 0; i < numpoints; i++)
|
|
{
|
|
if (i == numpoints - 1)
|
|
{
|
|
if (IsBadPolygonAngle(points[i * 2], points[i * 2 + 1], points[0], points[1], points[2], points[3]))
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
else if (i == numpoints - 2)
|
|
{
|
|
if (IsBadPolygonAngle(points[i * 2], points[i * 2 + 1], points[(i + 1) * 2], points[(i + 1) * 2 + 1], points[0], points[1]))
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
else if (IsBadPolygonAngle(points[i * 2], points[i * 2 + 1], points[(i + 1) * 2], points[(i + 1) * 2 + 1], points[(i + 2) * 2], points[(i + 2) * 2 + 1]))
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
private bool IsBadPolygonAngle(double x1, double y1, double x2, double y2, double x3, double y3)
|
|
{
|
|
double num = x1 - x2;
|
|
double num2 = y1 - y2;
|
|
double num3 = x2 - x3;
|
|
double num4 = y2 - y3;
|
|
double num5 = x3 - x1;
|
|
double num6 = y3 - y1;
|
|
double num7 = num * num + num2 * num2;
|
|
double num8 = num3 * num3 + num4 * num4;
|
|
double num9 = num5 * num5 + num6 * num6;
|
|
if (Math.Acos((num7 + num8 - num9) / (2.0 * Math.Sqrt(num7) * Math.Sqrt(num8))) < 2.0 * Math.Acos(Math.Sqrt(behavior.goodAngle)))
|
|
{
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
private void LineLineIntersection(double x1, double y1, double x2, double y2, double x3, double y3, double x4, double y4, ref double[] p)
|
|
{
|
|
double num = (y4 - y3) * (x2 - x1) - (x4 - x3) * (y2 - y1);
|
|
double num2 = (x4 - x3) * (y1 - y3) - (y4 - y3) * (x1 - x3);
|
|
double num3 = (x2 - x1) * (y1 - y3) - (y2 - y1) * (x1 - x3);
|
|
if (Math.Abs(num - 0.0) < 1E-50 && Math.Abs(num3 - 0.0) < 1E-50 && Math.Abs(num2 - 0.0) < 1E-50)
|
|
{
|
|
p[0] = 0.0;
|
|
return;
|
|
}
|
|
if (Math.Abs(num - 0.0) < 1E-50)
|
|
{
|
|
p[0] = 0.0;
|
|
return;
|
|
}
|
|
p[0] = 1.0;
|
|
num2 /= num;
|
|
num3 /= num;
|
|
p[1] = x1 + num2 * (x2 - x1);
|
|
p[2] = y1 + num2 * (y2 - y1);
|
|
}
|
|
|
|
private int HalfPlaneIntersection(int numvertices, ref double[] convexPoly, double x1, double y1, double x2, double y2)
|
|
{
|
|
double[] array = null;
|
|
int i = 0;
|
|
int num = 0;
|
|
double num2 = x2 - x1;
|
|
double num3 = y2 - y1;
|
|
int num4 = SplitConvexPolygon(numvertices, convexPoly, x1, y1, x2, y2, polys);
|
|
if (num4 == 3)
|
|
{
|
|
i = numvertices;
|
|
}
|
|
else
|
|
{
|
|
for (int j = 0; j < num4; j++)
|
|
{
|
|
double num5 = double.MaxValue;
|
|
double num6 = double.MinValue;
|
|
double num7;
|
|
for (int k = 1; (double)k <= 2.0 * polys[j][0] - 1.0; k += 2)
|
|
{
|
|
num7 = num2 * (polys[j][k + 1] - y1) - num3 * (polys[j][k] - x1);
|
|
num5 = ((num7 < num5) ? num7 : num5);
|
|
num6 = ((num7 > num6) ? num7 : num6);
|
|
}
|
|
num7 = ((Math.Abs(num5) > Math.Abs(num6)) ? num5 : num6);
|
|
if (num7 > 0.0)
|
|
{
|
|
array = polys[j];
|
|
num = 1;
|
|
break;
|
|
}
|
|
}
|
|
if (num == 1)
|
|
{
|
|
for (; (double)i < array[0]; i++)
|
|
{
|
|
convexPoly[2 * i] = array[2 * i + 1];
|
|
convexPoly[2 * i + 1] = array[2 * i + 2];
|
|
}
|
|
}
|
|
}
|
|
return i;
|
|
}
|
|
|
|
private int SplitConvexPolygon(int numvertices, double[] convexPoly, double x1, double y1, double x2, double y2, double[][] polys)
|
|
{
|
|
int num = 0;
|
|
double[] p = new double[3];
|
|
int num2 = 0;
|
|
int num3 = 0;
|
|
double num4 = 1E-12;
|
|
int num5 = 0;
|
|
int num6 = 0;
|
|
int num7 = 0;
|
|
int num8 = 0;
|
|
int num9 = 0;
|
|
int num10 = 0;
|
|
int num11 = 0;
|
|
int num12 = 0;
|
|
for (int i = 0; i < 2 * numvertices; i += 2)
|
|
{
|
|
int num13 = ((i + 2 < 2 * numvertices) ? (i + 2) : 0);
|
|
LineLineSegmentIntersection(x1, y1, x2, y2, convexPoly[i], convexPoly[i + 1], convexPoly[num13], convexPoly[num13 + 1], ref p);
|
|
if (Math.Abs(p[0] - 0.0) <= num4)
|
|
{
|
|
if (num == 1)
|
|
{
|
|
num3++;
|
|
poly2[2 * num3 - 1] = convexPoly[num13];
|
|
poly2[2 * num3] = convexPoly[num13 + 1];
|
|
}
|
|
else
|
|
{
|
|
num2++;
|
|
poly1[2 * num2 - 1] = convexPoly[num13];
|
|
poly1[2 * num2] = convexPoly[num13 + 1];
|
|
}
|
|
num5++;
|
|
continue;
|
|
}
|
|
if (Math.Abs(p[0] - 2.0) <= num4)
|
|
{
|
|
num2++;
|
|
poly1[2 * num2 - 1] = convexPoly[num13];
|
|
poly1[2 * num2] = convexPoly[num13 + 1];
|
|
num6++;
|
|
continue;
|
|
}
|
|
num7++;
|
|
if (Math.Abs(p[1] - convexPoly[num13]) <= num4 && Math.Abs(p[2] - convexPoly[num13 + 1]) <= num4)
|
|
{
|
|
num8++;
|
|
switch (num)
|
|
{
|
|
case 1:
|
|
num3++;
|
|
poly2[2 * num3 - 1] = convexPoly[num13];
|
|
poly2[2 * num3] = convexPoly[num13 + 1];
|
|
num2++;
|
|
poly1[2 * num2 - 1] = convexPoly[num13];
|
|
poly1[2 * num2] = convexPoly[num13 + 1];
|
|
num++;
|
|
break;
|
|
case 0:
|
|
num11++;
|
|
num2++;
|
|
poly1[2 * num2 - 1] = convexPoly[num13];
|
|
poly1[2 * num2] = convexPoly[num13 + 1];
|
|
if (i + 4 < 2 * numvertices)
|
|
{
|
|
int num14 = LinePointLocation(x1, y1, x2, y2, convexPoly[i], convexPoly[i + 1]);
|
|
int num15 = LinePointLocation(x1, y1, x2, y2, convexPoly[i + 4], convexPoly[i + 5]);
|
|
if (num14 != num15 && num14 != 0 && num15 != 0)
|
|
{
|
|
num12++;
|
|
num3++;
|
|
poly2[2 * num3 - 1] = convexPoly[num13];
|
|
poly2[2 * num3] = convexPoly[num13 + 1];
|
|
num++;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
else if (!(Math.Abs(p[1] - convexPoly[i]) <= num4) || !(Math.Abs(p[2] - convexPoly[i + 1]) <= num4))
|
|
{
|
|
num9++;
|
|
num2++;
|
|
poly1[2 * num2 - 1] = p[1];
|
|
poly1[2 * num2] = p[2];
|
|
num3++;
|
|
poly2[2 * num3 - 1] = p[1];
|
|
poly2[2 * num3] = p[2];
|
|
switch (num)
|
|
{
|
|
case 1:
|
|
num2++;
|
|
poly1[2 * num2 - 1] = convexPoly[num13];
|
|
poly1[2 * num2] = convexPoly[num13 + 1];
|
|
break;
|
|
case 0:
|
|
num3++;
|
|
poly2[2 * num3 - 1] = convexPoly[num13];
|
|
poly2[2 * num3] = convexPoly[num13 + 1];
|
|
break;
|
|
}
|
|
num++;
|
|
}
|
|
else
|
|
{
|
|
num10++;
|
|
if (num == 1)
|
|
{
|
|
num3++;
|
|
poly2[2 * num3 - 1] = convexPoly[num13];
|
|
poly2[2 * num3] = convexPoly[num13 + 1];
|
|
}
|
|
else
|
|
{
|
|
num2++;
|
|
poly1[2 * num2 - 1] = convexPoly[num13];
|
|
poly1[2 * num2] = convexPoly[num13 + 1];
|
|
}
|
|
}
|
|
}
|
|
int result;
|
|
if (num != 0 && num != 2)
|
|
{
|
|
result = 3;
|
|
}
|
|
else
|
|
{
|
|
result = ((num == 0) ? 1 : 2);
|
|
poly1[0] = num2;
|
|
poly2[0] = num3;
|
|
polys[0] = poly1;
|
|
if (num == 2)
|
|
{
|
|
polys[1] = poly2;
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
private int LinePointLocation(double x1, double y1, double x2, double y2, double x, double y)
|
|
{
|
|
if (Math.Atan((y2 - y1) / (x2 - x1)) * 180.0 / Math.PI == 90.0)
|
|
{
|
|
if (Math.Abs(x1 - x) <= 1E-11)
|
|
{
|
|
return 0;
|
|
}
|
|
}
|
|
else if (Math.Abs(y1 + (y2 - y1) * (x - x1) / (x2 - x1) - y) <= 1E-50)
|
|
{
|
|
return 0;
|
|
}
|
|
double num = (x2 - x1) * (y - y1) - (y2 - y1) * (x - x1);
|
|
if (Math.Abs(num - 0.0) <= 1E-11)
|
|
{
|
|
return 0;
|
|
}
|
|
if (num > 0.0)
|
|
{
|
|
return 1;
|
|
}
|
|
return 2;
|
|
}
|
|
|
|
private void LineLineSegmentIntersection(double x1, double y1, double x2, double y2, double x3, double y3, double x4, double y4, ref double[] p)
|
|
{
|
|
double num = 1E-13;
|
|
double num2 = (y4 - y3) * (x2 - x1) - (x4 - x3) * (y2 - y1);
|
|
double num3 = (x4 - x3) * (y1 - y3) - (y4 - y3) * (x1 - x3);
|
|
double num4 = (x2 - x1) * (y1 - y3) - (y2 - y1) * (x1 - x3);
|
|
if (Math.Abs(num2 - 0.0) < num)
|
|
{
|
|
if (Math.Abs(num4 - 0.0) < num && Math.Abs(num3 - 0.0) < num)
|
|
{
|
|
p[0] = 2.0;
|
|
}
|
|
else
|
|
{
|
|
p[0] = 0.0;
|
|
}
|
|
return;
|
|
}
|
|
num4 /= num2;
|
|
num3 /= num2;
|
|
if (num4 < 0.0 - num || num4 > 1.0 + num)
|
|
{
|
|
p[0] = 0.0;
|
|
return;
|
|
}
|
|
p[0] = 1.0;
|
|
p[1] = x1 + num3 * (x2 - x1);
|
|
p[2] = y1 + num3 * (y2 - y1);
|
|
}
|
|
|
|
private void FindPolyCentroid(int numpoints, double[] points, ref double[] centroid)
|
|
{
|
|
centroid[0] = 0.0;
|
|
centroid[1] = 0.0;
|
|
for (int i = 0; i < 2 * numpoints; i += 2)
|
|
{
|
|
centroid[0] = centroid[0] + points[i];
|
|
centroid[1] = centroid[1] + points[i + 1];
|
|
}
|
|
centroid[0] = centroid[0] / (double)numpoints;
|
|
centroid[1] = centroid[1] / (double)numpoints;
|
|
}
|
|
|
|
private void CircleLineIntersection(double x1, double y1, double x2, double y2, double x3, double y3, double r, ref double[] p)
|
|
{
|
|
double num = (x2 - x1) * (x2 - x1) + (y2 - y1) * (y2 - y1);
|
|
double num2 = 2.0 * ((x2 - x1) * (x1 - x3) + (y2 - y1) * (y1 - y3));
|
|
double num3 = x3 * x3 + y3 * y3 + x1 * x1 + y1 * y1 - 2.0 * (x3 * x1 + y3 * y1) - r * r;
|
|
double num4 = num2 * num2 - 4.0 * num * num3;
|
|
if (num4 < 0.0)
|
|
{
|
|
p[0] = 0.0;
|
|
}
|
|
else if (Math.Abs(num4 - 0.0) < 1E-50)
|
|
{
|
|
p[0] = 1.0;
|
|
double num5 = (0.0 - num2) / (2.0 * num);
|
|
p[1] = x1 + num5 * (x2 - x1);
|
|
p[2] = y1 + num5 * (y2 - y1);
|
|
}
|
|
else if (num4 > 0.0 && !(Math.Abs(num - 0.0) < 1E-50))
|
|
{
|
|
p[0] = 2.0;
|
|
double num5 = (0.0 - num2 + Math.Sqrt(num4)) / (2.0 * num);
|
|
p[1] = x1 + num5 * (x2 - x1);
|
|
p[2] = y1 + num5 * (y2 - y1);
|
|
num5 = (0.0 - num2 - Math.Sqrt(num4)) / (2.0 * num);
|
|
p[3] = x1 + num5 * (x2 - x1);
|
|
p[4] = y1 + num5 * (y2 - y1);
|
|
}
|
|
else
|
|
{
|
|
p[0] = 0.0;
|
|
}
|
|
}
|
|
|
|
private bool ChooseCorrectPoint(double x1, double y1, double x2, double y2, double x3, double y3, bool isObtuse)
|
|
{
|
|
double num = (x2 - x3) * (x2 - x3) + (y2 - y3) * (y2 - y3);
|
|
double num2 = (x2 - x1) * (x2 - x1) + (y2 - y1) * (y2 - y1);
|
|
if (isObtuse)
|
|
{
|
|
if (num2 >= num)
|
|
{
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
if (num2 < num)
|
|
{
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
private void PointBetweenPoints(double x1, double y1, double x2, double y2, double x, double y, ref double[] p)
|
|
{
|
|
if ((x2 - x) * (x2 - x) + (y2 - y) * (y2 - y) < (x2 - x1) * (x2 - x1) + (y2 - y1) * (y2 - y1))
|
|
{
|
|
p[0] = 1.0;
|
|
p[1] = (x - x2) * (x - x2) + (y - y2) * (y - y2);
|
|
p[2] = x;
|
|
p[3] = y;
|
|
}
|
|
else
|
|
{
|
|
p[0] = 0.0;
|
|
p[1] = 0.0;
|
|
p[2] = 0.0;
|
|
p[3] = 0.0;
|
|
}
|
|
}
|
|
|
|
private bool IsBadTriangleAngle(double x1, double y1, double x2, double y2, double x3, double y3)
|
|
{
|
|
double num = x1 - x2;
|
|
double num2 = y1 - y2;
|
|
double num3 = x2 - x3;
|
|
double num4 = y2 - y3;
|
|
double num5 = x3 - x1;
|
|
double num6 = y3 - y1;
|
|
double num7 = num * num;
|
|
double num8 = num2 * num2;
|
|
double num9 = num3 * num3;
|
|
double num10 = num4 * num4;
|
|
double num11 = num5 * num5;
|
|
double num12 = num6 * num6;
|
|
double num13 = num7 + num8;
|
|
double num14 = num9 + num10;
|
|
double num15 = num11 + num12;
|
|
double num16;
|
|
if (num13 < num14 && num13 < num15)
|
|
{
|
|
num16 = num3 * num5 + num4 * num6;
|
|
num16 = num16 * num16 / (num14 * num15);
|
|
}
|
|
else if (num14 < num15)
|
|
{
|
|
num16 = num * num5 + num2 * num6;
|
|
num16 = num16 * num16 / (num13 * num15);
|
|
}
|
|
else
|
|
{
|
|
num16 = num * num3 + num2 * num4;
|
|
num16 = num16 * num16 / (num13 * num14);
|
|
}
|
|
double num17 = ((num13 > num14 && num13 > num15) ? ((num14 + num15 - num13) / (2.0 * Math.Sqrt(num14 * num15))) : ((!(num14 > num15)) ? ((num13 + num14 - num15) / (2.0 * Math.Sqrt(num13 * num14))) : ((num13 + num15 - num14) / (2.0 * Math.Sqrt(num13 * num15)))));
|
|
if (num16 > behavior.goodAngle || (behavior.MaxAngle != 0.0 && num17 < behavior.maxGoodAngle))
|
|
{
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
private double MinDistanceToNeighbor(double newlocX, double newlocY, ref Otri searchtri)
|
|
{
|
|
Otri ot = default(Otri);
|
|
LocateResult locateResult = LocateResult.Outside;
|
|
Point point = new Point(newlocX, newlocY);
|
|
Vertex vertex = searchtri.Org();
|
|
Vertex vertex2 = searchtri.Dest();
|
|
if (vertex.x == point.x && vertex.y == point.y)
|
|
{
|
|
locateResult = LocateResult.OnVertex;
|
|
searchtri.Copy(ref ot);
|
|
}
|
|
else if (vertex2.x == point.x && vertex2.y == point.y)
|
|
{
|
|
searchtri.Lnext();
|
|
locateResult = LocateResult.OnVertex;
|
|
searchtri.Copy(ref ot);
|
|
}
|
|
else
|
|
{
|
|
double num = predicates.CounterClockwise(vertex, vertex2, point);
|
|
if (num < 0.0)
|
|
{
|
|
searchtri.Sym();
|
|
searchtri.Copy(ref ot);
|
|
locateResult = mesh.locator.PreciseLocate(point, ref ot, stopatsubsegment: false);
|
|
}
|
|
else if (num == 0.0)
|
|
{
|
|
if (vertex.x < point.x == point.x < vertex2.x && vertex.y < point.y == point.y < vertex2.y)
|
|
{
|
|
locateResult = LocateResult.OnEdge;
|
|
searchtri.Copy(ref ot);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
searchtri.Copy(ref ot);
|
|
locateResult = mesh.locator.PreciseLocate(point, ref ot, stopatsubsegment: false);
|
|
}
|
|
}
|
|
if (locateResult == LocateResult.OnVertex || locateResult == LocateResult.Outside)
|
|
{
|
|
return 0.0;
|
|
}
|
|
Vertex vertex3 = ot.Org();
|
|
Vertex vertex4 = ot.Dest();
|
|
Vertex vertex5 = ot.Apex();
|
|
double num2 = (vertex3.x - point.x) * (vertex3.x - point.x) + (vertex3.y - point.y) * (vertex3.y - point.y);
|
|
double num3 = (vertex4.x - point.x) * (vertex4.x - point.x) + (vertex4.y - point.y) * (vertex4.y - point.y);
|
|
double num4 = (vertex5.x - point.x) * (vertex5.x - point.x) + (vertex5.y - point.y) * (vertex5.y - point.y);
|
|
if (num2 <= num3 && num2 <= num4)
|
|
{
|
|
return num2;
|
|
}
|
|
if (num3 <= num4)
|
|
{
|
|
return num3;
|
|
}
|
|
return num4;
|
|
}
|
|
}
|
|
}
|