private static void DoCubicMidpointSubdivision(Point[] controlPoints, uint depth, double inverseErrorTolerance, List <Point> resultPolyline)
{
Point[] controlPoints1 = new Point[4]
{
controlPoints[0],
controlPoints[1],
controlPoints[2],
controlPoints[3]
};
Point[] controlPoints2 = new Point[4];
controlPoints2[3] = controlPoints1[3];
controlPoints1[3] = VectorUtilities.Midpoint(controlPoints1[3], controlPoints1[2]);
controlPoints1[2] = VectorUtilities.Midpoint(controlPoints1[2], controlPoints1[1]);
controlPoints1[1] = VectorUtilities.Midpoint(controlPoints1[1], controlPoints1[0]);
controlPoints2[2] = controlPoints1[3];
controlPoints1[3] = VectorUtilities.Midpoint(controlPoints1[3], controlPoints1[2]);
controlPoints1[2] = VectorUtilities.Midpoint(controlPoints1[2], controlPoints1[1]);
controlPoints2[1] = controlPoints1[3];
controlPoints1[3] = VectorUtilities.Midpoint(controlPoints1[3], controlPoints1[2]);
controlPoints2[0] = controlPoints1[3];
--depth;
if (depth > 0U)
{
BezierCurveFlattener.DoCubicMidpointSubdivision(controlPoints1, depth, inverseErrorTolerance, resultPolyline);
resultPolyline.Add(controlPoints2[0]);
BezierCurveFlattener.DoCubicMidpointSubdivision(controlPoints2, depth, inverseErrorTolerance, resultPolyline);
}
else
{
BezierCurveFlattener.DoCubicForwardDifferencing(controlPoints1, inverseErrorTolerance, resultPolyline);
resultPolyline.Add(controlPoints2[0]);
BezierCurveFlattener.DoCubicForwardDifferencing(controlPoints2, inverseErrorTolerance, resultPolyline);
}
}
private static void DoCubicForwardDifferencing(Point[] controlPoints, double leftParameter, double rightParameter, double inverseErrorTolerance, List <Point> resultPolyline, List <double> resultParameters)
{
double num1 = controlPoints[1].X - controlPoints[0].X;
double num2 = controlPoints[1].Y - controlPoints[0].Y;
double num3 = controlPoints[2].X - controlPoints[1].X;
double num4 = controlPoints[2].Y - controlPoints[1].Y;
double num5 = controlPoints[3].X - controlPoints[2].X;
double num6 = controlPoints[3].Y - controlPoints[2].Y;
double num7 = num3 - num1;
double num8 = num4 - num2;
double num9 = num5 - num3;
double num10 = num6 - num4;
double num11 = num9 - num7;
double num12 = num10 - num8;
Vector vector = controlPoints[3] - controlPoints[0];
double length = vector.Length;
double num13 = length < FloatingPointArithmetic.DistanceTolerance ? Math.Max(0.0, Math.Max(VectorUtilities.Distance(controlPoints[1], controlPoints[0]), VectorUtilities.Distance(controlPoints[2], controlPoints[0]))) : Math.Max(0.0, Math.Max(Math.Abs((num7 * vector.Y - num8 * vector.X) / length), Math.Abs((num9 * vector.Y - num10 * vector.X) / length)));
uint num14 = 0U;
if (num13 > 0.0)
{
double d = num13 * inverseErrorTolerance;
num14 = d < (double)int.MaxValue ? BezierCurveFlattener.Log4UnsignedInt32((uint)(d + 0.5)) : BezierCurveFlattener.Log4Double(d);
}
int exp1 = -(int)num14;
int exp2 = exp1 + exp1;
int exp3 = exp2 + exp1;
double num15 = FloatingPointArithmetic.DoubleFromMantissaAndExponent(3.0 * num7, exp2);
double num16 = FloatingPointArithmetic.DoubleFromMantissaAndExponent(3.0 * num8, exp2);
double num17 = FloatingPointArithmetic.DoubleFromMantissaAndExponent(6.0 * num11, exp3);
double num18 = FloatingPointArithmetic.DoubleFromMantissaAndExponent(6.0 * num12, exp3);
double num19 = FloatingPointArithmetic.DoubleFromMantissaAndExponent(3.0 * num1, exp1) + num15 + 1.0 / 6.0 * num17;
double num20 = FloatingPointArithmetic.DoubleFromMantissaAndExponent(3.0 * num2, exp1) + num16 + 1.0 / 6.0 * num18;
double num21 = 2.0 * num15 + num17;
double num22 = 2.0 * num16 + num18;
double x = controlPoints[0].X;
double y = controlPoints[0].Y;
Point point = new Point(0.0, 0.0);
int num23 = 1 << (int)num14;
double num24 = num23 > 0 ? (rightParameter - leftParameter) / (double)num23 : 0.0;
double num25 = leftParameter;
for (int index = 1; index < num23; ++index)
{
x += num19;
y += num20;
point.X = x;
point.Y = y;
resultPolyline.Add(point);
num25 += num24;
resultParameters.Add(num25);
num19 += num21;
num20 += num22;
num21 += num17;
num22 += num18;
}
}
public static void FlattenQuadratic(Point[] controlPoints, double errorTolerance, List <Point> resultPolyline, bool connect)
{
BezierCurveFlattener.FlattenCubic(new Point[4]
{
controlPoints[0],
VectorUtilities.WeightedAverage(controlPoints[0], controlPoints[1], 2.0 / 3.0),
VectorUtilities.WeightedAverage(controlPoints[1], controlPoints[2], 1.0 / 3.0),
controlPoints[2]
}, errorTolerance, resultPolyline, connect);
}
public static bool CompareAlgorithmsOnChordMonotoneCubic(Point[] controlPoints, double errorTolerance)
{
if (!BezierCurveFlattener.IsCubicChordMonotone(controlPoints, errorTolerance * errorTolerance))
{
return(false);
}
List <Point> list1 = new List <Point>(16);
List <Point> list2 = new List <Point>(16);
list1.Add(controlPoints[0]);
list2.Add(controlPoints[0]);
double x = controlPoints[3].X - controlPoints[2].X + controlPoints[1].X - controlPoints[0].X;
double y = controlPoints[3].Y - controlPoints[2].Y + controlPoints[1].Y - controlPoints[0].Y;
double num = 1.0 / errorTolerance;
uint depth = BezierCurveFlattener.Log8UnsignedInt32((uint)(FloatingPointArithmetic.Hypotenuse(x, y) * num + 0.5));
if (depth > 0U)
{
--depth;
}
if (depth > 0U)
{
BezierCurveFlattener.DoCubicMidpointSubdivision(controlPoints, depth, 0.75 * num, list1);
}
else
{
BezierCurveFlattener.DoCubicForwardDifferencing(controlPoints, 0.75 * num, list1);
}
BezierCurveFlattener.AdaptiveForwardDifferencingCubicFlattener differencingCubicFlattener = new BezierCurveFlattener.AdaptiveForwardDifferencingCubicFlattener(controlPoints, errorTolerance, errorTolerance, false);
Point p = new Point();
while (differencingCubicFlattener.Next(ref p))
{
list2.Add(p);
}
list1.Add(controlPoints[3]);
list2.Add(controlPoints[3]);
double[] cumulatedChordLength1 = VectorUtilities.GetCumulatedChordLength(list1, 0, list1.Count - 1);
double[] cumulatedChordLength2 = VectorUtilities.GetCumulatedChordLength(list2, 0, list2.Count - 1);
int firstBadVertexInQ = 0;
return(VectorUtilities.ArePolylinesClose(list1, cumulatedChordLength1, 0, list1.Count - 1, list2, cumulatedChordLength2, 0, list2.Count - 1, errorTolerance, ref firstBadVertexInQ));
}
public static void FlattenCubic(Point[] controlPoints, double errorTolerance, List <Point> resultPolyline, bool connect, List <double> resultParameters)
{
if (!connect || resultPolyline.Count == 0)
{
resultPolyline.Add(controlPoints[0]);
resultParameters.Add(0.0);
}
if (BezierCurveFlattener.IsCubicChordMonotone(controlPoints, errorTolerance * errorTolerance))
{
BezierCurveFlattener.AdaptiveForwardDifferencingCubicFlattener differencingCubicFlattener = new BezierCurveFlattener.AdaptiveForwardDifferencingCubicFlattener(controlPoints, errorTolerance, errorTolerance, true);
Point p = new Point();
double u = 0.0;
while (differencingCubicFlattener.Next(ref p, ref u))
{
resultPolyline.Add(p);
resultParameters.Add(u);
}
}
else
{
double x = controlPoints[3].X - controlPoints[2].X + controlPoints[1].X - controlPoints[0].X;
double y = controlPoints[3].Y - controlPoints[2].Y + controlPoints[1].Y - controlPoints[0].Y;
double num = 1.0 / errorTolerance;
uint depth = BezierCurveFlattener.Log8UnsignedInt32((uint)(FloatingPointArithmetic.Hypotenuse(x, y) * num + 0.5));
if (depth > 0U)
{
--depth;
}
if (depth > 0U)
{
BezierCurveFlattener.DoCubicMidpointSubdivision(controlPoints, depth, 0.0, 1.0, 0.75 * num, resultPolyline, resultParameters);
}
else
{
BezierCurveFlattener.DoCubicForwardDifferencing(controlPoints, 0.0, 1.0, 0.75 * num, resultPolyline, resultParameters);
}
}
resultPolyline.Add(controlPoints[3]);
resultParameters.Add(1.0);
}
private static void DoCubicMidpointSubdivision(Point[] controlPoints, uint depth, double leftParameter, double rightParameter, double inverseErrorTolerance, List <Point> resultPolyline, List <double> resultParameters)
{
Point[] controlPoints1 = new Point[4]
{
controlPoints[0],
controlPoints[1],
controlPoints[2],
controlPoints[3]
};
Point[] controlPoints2 = new Point[4];
controlPoints2[3] = controlPoints1[3];
controlPoints1[3] = VectorUtilities.Midpoint(controlPoints1[3], controlPoints1[2]);
controlPoints1[2] = VectorUtilities.Midpoint(controlPoints1[2], controlPoints1[1]);
controlPoints1[1] = VectorUtilities.Midpoint(controlPoints1[1], controlPoints1[0]);
controlPoints2[2] = controlPoints1[3];
controlPoints1[3] = VectorUtilities.Midpoint(controlPoints1[3], controlPoints1[2]);
controlPoints1[2] = VectorUtilities.Midpoint(controlPoints1[2], controlPoints1[1]);
controlPoints2[1] = controlPoints1[3];
controlPoints1[3] = VectorUtilities.Midpoint(controlPoints1[3], controlPoints1[2]);
controlPoints2[0] = controlPoints1[3];
--depth;
double num = (leftParameter + rightParameter) * 0.5;
if (depth > 0U)
{
BezierCurveFlattener.DoCubicMidpointSubdivision(controlPoints1, depth, leftParameter, num, inverseErrorTolerance, resultPolyline, resultParameters);
resultPolyline.Add(controlPoints2[0]);
resultParameters.Add(num);
BezierCurveFlattener.DoCubicMidpointSubdivision(controlPoints2, depth, num, rightParameter, inverseErrorTolerance, resultPolyline, resultParameters);
}
else
{
BezierCurveFlattener.DoCubicForwardDifferencing(controlPoints1, leftParameter, num, inverseErrorTolerance, resultPolyline, resultParameters);
resultPolyline.Add(controlPoints2[0]);
resultParameters.Add(num);
BezierCurveFlattener.DoCubicForwardDifferencing(controlPoints2, num, rightParameter, inverseErrorTolerance, resultPolyline, resultParameters);
}
}
private void OpenFit2DFromTo(int first, Vector unitTangentFirst, int last, Vector unitTangentLast, bool onlyCubics)
{
int length = last - first + 1;
int num1 = length - 1;
PathFigureEditor pathFigureEditor = new PathFigureEditor(this.figure);
if (length == 2)
{
if (onlyCubics)
{
double num2 = VectorUtilities.Distance(this.sample[first], this.sample[last]) / 3.0;
Point p1 = this.sample[first] + unitTangentFirst * num2;
Point p2 = this.sample[last] - unitTangentLast * num2;
pathFigureEditor.CubicCurveTo(p1, p2, this.sample[last]);
}
else
{
pathFigureEditor.LineTo(this.sample[last]);
}
}
else if (length == 3)
{
int index1 = first + 1;
Vector vector1 = this.sample[first] - this.sample[index1];
Vector vector2 = this.sample[last] - this.sample[index1];
Vector vector3 = vector1;
vector3.Normalize();
Vector vector4 = vector2;
vector4.Normalize();
Vector vector5 = vector3 + vector4;
Vector vector6;
if (VectorUtilities.IsZero(vector5))
{
vector6 = this.sample[last] - this.sample[first];
vector6.Normalize();
}
else
{
vector6 = VectorUtilities.UnitNormal(vector5);
}
if (VectorUtilities.Dot(vector6, this.sample[last] - this.sample[first]) < 0.0)
{
vector6 *= -1.0;
}
this.OpenFit2DFromTo(first, unitTangentFirst, index1, vector6, onlyCubics);
int index2 = PathFigureUtilities.PointCount(this.figure) - 1;
this.OpenFit2DFromTo(index1, vector6, last, unitTangentLast, onlyCubics);
this.SetupCollinearHandlesConstraint(index2, onlyCubics);
}
else
{
double[][] numArray1 = new double[length][];
for (int index = 0; index < length; ++index)
{
numArray1[index] = new double[4];
}
double num2 = 1.0 / (this.chordLength[last] - this.chordLength[first]);
double[] numArray2 = new double[length];
for (int index = 0; index <= num1; ++index)
{
numArray2[index] = (this.chordLength[first + index] - this.chordLength[first]) * num2;
}
double[] numArray3 = new double[4];
numArray3[0] = 1.0;
for (int index1 = 0; index1 <= num1; ++index1)
{
numArray3[1] = 1.0 - numArray2[index1];
for (int index2 = 2; index2 <= 3; ++index2)
{
numArray3[index2] = numArray3[index2 - 1] * numArray3[1];
}
numArray1[index1][0] = numArray3[3];
double num3 = numArray2[index1];
int index3 = 1;
while (index3 <= 3)
{
numArray1[index1][index3] = (double)BezierCurveFitter.pascalTriangle[3][index3] * num3 * numArray3[3 - index3];
++index3;
num3 *= numArray2[index1];
}
}
double[][] numArray4 = new double[4][];
for (int index = 0; index < 4; ++index)
{
numArray4[index] = new double[4];
}
for (int index1 = 0; index1 <= 3; ++index1)
{
for (int index2 = 0; index2 <= index1; ++index2)
{
for (int index3 = 0; index3 <= num1; ++index3)
{
numArray4[index1][index2] += numArray1[index3][index2] * numArray1[index3][index1];
}
if (index1 != index2)
{
numArray4[index2][index1] = numArray4[index1][index2];
}
}
}
double[][] m = new double[2][]
{
new double[2]
{
numArray4[1][1],
numArray4[1][2] * VectorUtilities.Dot(unitTangentFirst, unitTangentLast)
},
new double[2]
{
numArray4[1][2],
numArray4[2][2]
}
};
double[] v = new double[2];
Vector[] vectorArray = new Vector[4];
for (int index1 = 0; index1 < 4; ++index1)
{
for (int index2 = 0; index2 <= num1; ++index2)
{
vectorArray[index1].X += numArray1[index2][index1] * this.sample[index2 + first].X;
vectorArray[index1].Y += numArray1[index2][index1] * this.sample[index2 + first].Y;
}
}
Vector vector1 = new Vector(this.sample[first].X, this.sample[first].Y);
Vector vector2 = new Vector(this.sample[last].X, this.sample[last].Y);
Vector b1 = (numArray4[1][0] + numArray4[1][1]) * vector1 + (numArray4[1][2] + numArray4[1][3]) * vector2 - vectorArray[1];
v[0] = -VectorUtilities.Dot(unitTangentFirst, b1);
Vector b2 = (numArray4[2][0] + numArray4[2][1]) * vector1 + (numArray4[2][2] + numArray4[2][3]) * vector2 - vectorArray[2];
v[1] = -VectorUtilities.Dot(unitTangentLast, b2);
bool flag = BezierCurveFitter.Solve2By2LinearSystem(m, v);
int firstBadVertexInQ = 0;
if (flag && v[0] > 0.0 && v[1] < 0.0)
{
Point[] controlPoints = new Point[4];
controlPoints[0] = this.sample[first];
controlPoints[1] = controlPoints[0] + v[0] * unitTangentFirst;
controlPoints[3] = this.sample[last];
controlPoints[2] = controlPoints[3] + v[1] * unitTangentLast;
List <Point> list = new List <Point>(128);
BezierCurveFlattener.FlattenCubic(controlPoints, this.distanceTolerance, list, false);
double[] cumulatedChordLength = VectorUtilities.GetCumulatedChordLength(list, 0, list.Count - 1);
if (VectorUtilities.ArePolylinesClose(list, cumulatedChordLength, 0, list.Count - 1, this.sample, this.chordLength, first, last, this.distanceTolerance, ref firstBadVertexInQ))
{
pathFigureEditor.CubicCurveTo(controlPoints[1], controlPoints[2], controlPoints[3]);
return;
}
}
int num4 = (first + last) / 2;
Vector tangentVectorAtSplit = this.GetUnitTangentVectorAtSplit(num4);
this.OpenFit2DFromTo(first, unitTangentFirst, num4, tangentVectorAtSplit, onlyCubics);
int index4 = PathFigureUtilities.PointCount(this.figure) - 1;
this.OpenFit2DFromTo(num4, tangentVectorAtSplit, last, unitTangentLast, onlyCubics);
this.SetupCollinearHandlesConstraint(index4, onlyCubics);
}
}
