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); } }