private static Point2D smethod_14( double param, Interface28 xInterval, Interface28 yInterval) { int num1 = (int)System.Math.Floor(param); double num2 = param - (double)num1; switch (num1 & 3) { case 0: return(new Point2D(xInterval.Start + num2 * (xInterval.End - xInterval.Start), yInterval.Start)); case 1: return(new Point2D(xInterval.End, yInterval.Start + num2 * (yInterval.End - yInterval.Start))); case 2: return(new Point2D(xInterval.End + num2 * (xInterval.Start - xInterval.End), yInterval.End)); case 3: return(new Point2D(xInterval.Start, yInterval.End + num2 * (yInterval.Start - yInterval.End))); default: throw new ArgumentException("Invalid parameter: " + (object)param); } }
public static Point2D smethod_8( Interface28 xInterval, Interface28 yInterval, Point2D point) { double x = Class794.smethod_7(xInterval, point.X); double y = Class794.smethod_7(yInterval, point.Y); if (x == point.X && y == point.Y) { return(point); } return(new Point2D(x, y)); }
private static Class794.Struct7 smethod_11(Interface28 interval, double t1, double t2) { double periodicLength = interval.PeriodicLength; bool highLow; if (t1 < interval.Start + 0.5 * periodicLength) { t2 -= periodicLength; highLow = false; } else { t1 -= periodicLength; highLow = true; } return(new Class794.Struct7(t1 == t2 ? 0.0 : t1 / (t1 - t2), highLow)); }
public static double smethod_7(Interface28 interval, double value) { if (interval.IsPeriodic) { if (!double.IsInfinity(value)) { double num = System.Math.Floor(value / interval.PeriodicLength); if (num < 0.0 || num >= 1.0) { value -= num * interval.PeriodicLength; } } else { value = 0.0; } } return(value); }
private static double smethod_13( Point2D p, Interface28 xInterval, Interface28 yInterval, double epsilon) { if (System.Math.Abs(xInterval.Start - p.X) <= epsilon) { return(3.0 + (p.Y - yInterval.End) / (yInterval.Start - yInterval.End)); } if (System.Math.Abs(yInterval.Start - p.Y) <= epsilon) { return((p.X - xInterval.Start) / (xInterval.End - xInterval.Start)); } if (System.Math.Abs(xInterval.End - p.X) <= epsilon) { return(1.0 + (p.Y - yInterval.Start) / (yInterval.End - yInterval.Start)); } if (System.Math.Abs(yInterval.End - p.Y) <= epsilon) { return(2.0 + (p.X - xInterval.End) / (xInterval.Start - xInterval.End)); } return(double.NegativeInfinity); }
public static Polygon2D[] smethod_9( Interface28 xInterval, Interface28 yInterval, Polygon2D[] outer, Polygon2D[] holes, bool right, double epsilon) { if (xInterval.IsUnbound || yInterval.IsUnbound) { Bounds2D bounds2D = new Bounds2D(); foreach (Polygon2D polygon2D in outer) { bounds2D.Update((IList <Point2D>)polygon2D); } if (!bounds2D.Initialized) { return((Polygon2D[])null); } if (xInterval.IsUnbound) { xInterval = (Interface28) new Class438(xInterval.HasUnboundStart ? bounds2D.Min.X : xInterval.Start, xInterval.HasUnboundEnd ? bounds2D.Max.X : xInterval.End, xInterval.PeriodicLength); } if (yInterval.IsUnbound) { yInterval = (Interface28) new Class438(yInterval.HasUnboundStart ? bounds2D.Min.Y : yInterval.Start, yInterval.HasUnboundEnd ? bounds2D.Max.Y : yInterval.End, yInterval.PeriodicLength); } } List <Polygon2D> polygon2DList = new List <Polygon2D>(); Polygon2D[] polygon2DArray1 = Class794.smethod_10(outer, right, true, xInterval, yInterval, epsilon); polygon2DList.AddRange((IEnumerable <Polygon2D>)polygon2DArray1); Polygon2D[] polygon2DArray2 = Class794.smethod_10(holes, right, false, xInterval, yInterval, epsilon); polygon2DList.AddRange((IEnumerable <Polygon2D>)polygon2DArray2); return(polygon2DList.ToArray()); }
internal Class764(Class1132 A_0, string A_1, Document A_2, Class861 A_3) : base(A_0, A_1) { this.document_0 = A_2; this.interface28_0 = new Class482(A_2, A_3, this); this.class861_0 = A_3; }
private static Polygon2D[] smethod_10( Polygon2D[] polies, bool right, bool outer, Interface28 xInterval, Interface28 yInterval, double epsilon) { bool isPeriodic1 = xInterval.IsPeriodic; bool isPeriodic2 = yInterval.IsPeriodic; if (!isPeriodic1 && !isPeriodic2) { return(polies); } List <Polygon2D> polygon2DList = new List <Polygon2D>(); double periodicLength1 = xInterval.PeriodicLength; double periodicLength2 = yInterval.PeriodicLength; Polygon2D polygon2D1 = new Polygon2D(); foreach (Polygon2D poly in polies) { int count = poly.Count; if (count > 0) { Point2D p1 = Class794.smethod_8(xInterval, yInterval, poly[0]); for (int index = 1; index <= count; ++index) { Point2D p2 = Class794.smethod_8(xInterval, yInterval, poly[index % count]); bool flag1 = isPeriodic1 && 2.0 * System.Math.Abs(p2.X - p1.X) > periodicLength1; bool flag2 = isPeriodic2 && 2.0 * System.Math.Abs(p2.Y - p1.Y) > periodicLength2; if (flag1 || flag2) { if (flag1 && flag2) { throw new NotSupportedException("Double interval crossing not yet supported!"); } Class794.Struct7 struct7 = flag1 ? Class794.smethod_11(xInterval, p1.X, p2.X) : Class794.smethod_11(yInterval, p1.Y, p2.Y); Point2D point2D = Class794.smethod_12(p1, p2, struct7.double_0); if (flag1) { point2D = new Point2D(struct7.bool_0 ? xInterval.End : xInterval.Start, point2D.Y); p2 = new Point2D(struct7.bool_0 ? xInterval.Start : xInterval.End, point2D.Y); } else { point2D = new Point2D(point2D.X, struct7.bool_0 ? yInterval.End : yInterval.Start); p2 = new Point2D(point2D.X, struct7.bool_0 ? yInterval.Start : yInterval.End); } polygon2D1.Add(point2D); polygon2DList.Add(polygon2D1); polygon2D1 = new Polygon2D(); } polygon2D1.Add(p2); p1 = p2; } } } if (polygon2D1.Count > 0) { if (polygon2DList.Count == 0) { polygon2DList.Add(polygon2D1); } else { polygon2DList.Add(polygon2D1); } } foreach (Polygon2D polygon2D2 in polygon2DList) { ; } return(polygon2DList.ToArray()); }
internal Class263(Interface28 A_0) { this.interface28_0 = A_0; }