/** * Appends a straight line segment from the current point to the point <CODE>(x, y)</CODE>. */ public virtual void LineTo(float x, float y) { if (currentPoint == null) { throw new Exception(START_PATH_ERR_MSG); } Point2D targetPoint = new Point2D.Float(x, y); this.LastSubpath.AddSegment(new Line(currentPoint, targetPoint)); currentPoint = targetPoint; }
/** * Begins a new subpath by moving the current point to coordinates <CODE>(x, y)</CODE>. */ public virtual void MoveTo(float x, float y) { currentPoint = new Point2D.Float(x, y); Subpath lastSubpath = this.LastSubpath; if (lastSubpath != null && lastSubpath.IsSinglePointOpen()) { lastSubpath.SetStartPoint(currentPoint); } else { subpaths.Add(new Subpath(currentPoint)); } }
public override bool AllowText(TextRenderInfo renderInfo) { LineSegment ascent = renderInfo.GetAscentLine(); LineSegment descent = renderInfo.GetDescentLine(); Point2D[] glyphRect = new Point2D[] { new Point2D.Float(ascent.GetStartPoint()[0], ascent.GetStartPoint()[1]), new Point2D.Float(ascent.GetEndPoint()[0], ascent.GetEndPoint()[1]), new Point2D.Float(descent.GetEndPoint()[0], descent.GetEndPoint()[1]), new Point2D.Float(descent.GetStartPoint()[0], descent.GetStartPoint()[1]), }; foreach (Rectangle rectangle in rectangles) { Point2D[] redactRect = GetVertices(rectangle); if (Intersect(glyphRect, redactRect)) { return false; } } return true; }
virtual public void SetLocation(Point2D p) { SetLocation(p.GetX(), p.GetY()); }
/** * Constructs a new line based on the given coordinates. */ public Line(Point2D p1, Point2D p2) : this((float) p1.GetX(), (float) p1.GetY(), (float) p2.GetX(), (float) p2.GetY()) { }
internal StandardLine(Point2D p1, Point2D p2) { A = (float) (p2.GetY() - p1.GetY()); B = (float) (p1.GetX() - p2.GetX()); C = (float) (p1.GetY() * (-B) - p1.GetX() * A); }
private static bool LiesOnSegment(Point2D segStart, Point2D segEnd, Point2D point) { return point.GetX() >= Math.Min(segStart.GetX(), segEnd.GetX()) && point.GetX() <= Math.Max(segStart.GetX(), segEnd.GetX()) && point.GetY() >= Math.Min(segStart.GetY(), segEnd.GetY()) && point.GetY() <= Math.Max(segStart.GetY(), segEnd.GetY()); }
private static double GetVectorEuclideanNorm(Point2D vector) { return vector.Distance(0, 0); }
private void WriteMoveTo(Point2D destinationPoint, PdfContentByte canvas) { new PdfNumber(destinationPoint.GetX()).ToPdf(canvas.PdfWriter, canvas.InternalBuffer); canvas.InternalBuffer.Append(' '); new PdfNumber(destinationPoint.GetY()).ToPdf(canvas.PdfWriter, canvas.InternalBuffer); canvas.InternalBuffer.Append(m); }
/** * Adds the subpaths to this path. * * @param subpaths {@link java.util.List} of subpaths to be added to this path. */ public void AddSubpaths(IList<Subpath> subpaths) { if (subpaths.Count > 0) { Util.AddAll(this.subpaths, subpaths); currentPoint = this.subpaths[subpaths.Count - 1].GetLastPoint(); } }
/** * Adds the subpath to this path. * * @param subpath The subpath to be added to this path. */ public void AddSubpath(Subpath subpath) { subpaths.Add(subpath); currentPoint = subpath.GetLastPoint(); }
/** * Appends a cubic Bezier curve to the current path. The curve shall extend from * the current point to the point <CODE>(x3, y3)</CODE>. */ public virtual void CurveTo(float x1, float y1, float x2, float y2, float x3, float y3) { if (currentPoint == null) { throw new Exception(START_PATH_ERR_MSG); } // Numbered in natural order Point2D secondPoint = new Point2D.Float(x1, y1); Point2D thirdPoint = new Point2D.Float(x2, y2); Point2D fourthPoint = new Point2D.Float(x3, y3); IList<Point2D> controlPoints = new List<Point2D>(new Point2D[] {currentPoint, secondPoint, thirdPoint, fourthPoint}); this.LastSubpath.AddSegment(new BezierCurve(controlPoints)); currentPoint = fourthPoint; }
public virtual bool Contains(Point2D point) { return Contains(point.GetX(), point.GetY()); }
virtual public Point2D InverseTransform(Point2D src, Point2D dst) { double det = GetDeterminant(); if (Math.Abs(det) < ZERO) { // awt.204=Determinant is zero throw new InvalidOperationException("awt.204"); //$NON-NLS-1$ } if (dst == null) { if (src is Point2D.Double) { dst = new Point2D.Double(); } else { dst = new Point2D.Float(); } } double x = src.GetX() - m02; double y = src.GetY() - m12; dst.SetLocation((x * m11 - y * m01) / det, (y * m00 - x * m10) / det); return dst; }
virtual public Point2D DeltaTransform(Point2D src, Point2D dst) { if (dst == null) { if (src is Point2D.Double) { dst = new Point2D.Double(); } else { dst = new Point2D.Float(); } } double x = src.GetX(); double y = src.GetY(); dst.SetLocation(x * m00 + y * m01, x * m10 + y * m11); return dst; }
private static Point2D ComponentwiseDiff(Point2D minuend, Point2D subtrahend) { return new Point2D.Float((float) (minuend.GetX() - subtrahend.GetX()), (float) (minuend.GetY() - subtrahend.GetY())); }
private static Point2D GetUnitVector(Point2D vector) { double vectorLength = GetVectorEuclideanNorm(vector); return new Point2D.Float((float) (vector.GetX() / vectorLength), (float) (vector.GetY() / vectorLength)); }
private static Subpath ConstructSquare(Point2D squareCenter, double widthHalf, double rotationAngle) { // Orthogonal square is the square with sides parallel to one of the axes. Point2D[] ortogonalSquareVertices = { new Point2D.Double(-widthHalf, -widthHalf), new Point2D.Double(-widthHalf, widthHalf), new Point2D.Double(widthHalf, widthHalf), new Point2D.Double(widthHalf, -widthHalf) }; Point2D[] rotatedSquareVertices = GetRotatedSquareVertices(ortogonalSquareVertices, rotationAngle, squareCenter); Subpath square = new Subpath(); square.AddSegment(new Line(rotatedSquareVertices[0], rotatedSquareVertices[1])); square.AddSegment(new Line(rotatedSquareVertices[1], rotatedSquareVertices[2])); square.AddSegment(new Line(rotatedSquareVertices[2], rotatedSquareVertices[3])); square.AddSegment(new Line(rotatedSquareVertices[3], rotatedSquareVertices[0])); return square; }
private static float ApplyDash(Path dashedPath, Point2D segStart, Point2D segEnd, Point2D dashTo, bool isGap) { float remainingDist = 0; if (!LiesOnSegment(segStart, segEnd, dashTo)) { remainingDist = (float) dashTo.Distance(segEnd); dashTo = segEnd; } if (isGap) { dashedPath.MoveTo((float) dashTo.GetX(), (float) dashTo.GetY()); } else { dashedPath.LineTo((float) dashTo.GetX(), (float) dashTo.GetY()); } return remainingDist; }
private static Point2D[] GetRotatedSquareVertices(Point2D[] orthogonalSquareVertices, double angle, Point2D squareCenter) { Point2D[] rotatedSquareVertices = new Point2D[orthogonalSquareVertices.Length]; AffineTransform.GetRotateInstance(angle). Transform(orthogonalSquareVertices, 0, rotatedSquareVertices, 0, rotatedSquareVertices.Length); AffineTransform.GetTranslateInstance(squareCenter.GetX(), squareCenter.GetY()). Transform(rotatedSquareVertices, 0, rotatedSquareVertices, 0, orthogonalSquareVertices.Length); return rotatedSquareVertices; }
private Point2D[] TransformPoints(Matrix transormationMatrix, bool inverse, params Point2D[] points) { AffineTransform t = new AffineTransform(transormationMatrix[Matrix.I11], transormationMatrix[Matrix.I12], transormationMatrix[Matrix.I21], transormationMatrix[Matrix.I22], transormationMatrix[Matrix.I31], transormationMatrix[Matrix.I32]); Point2D[] transformed = new Point2D[points.Length]; if (inverse) { t = t.CreateInverse(); } t.Transform(points, 0, transformed, 0, points.Length); return transformed; }
private static BezierCurve[] ApproximateCircle(Point2D center, double radius) { // The circle is split into 4 sectors. Arc of each sector // is approximated with bezier curve separately. BezierCurve[] approximation = new BezierCurve[4]; double x = center.GetX(); double y = center.GetY(); approximation[0] = new BezierCurve(new List<Point2D>(new Point2D[] { new Point2D.Double(x, y + radius), new Point2D.Double(x + radius * circleApproximationConst, y + radius), new Point2D.Double(x + radius, y + radius * circleApproximationConst), new Point2D.Double(x + radius, y) })); approximation[1] = new BezierCurve(new List<Point2D>(new Point2D[] { new Point2D.Double(x + radius, y), new Point2D.Double(x + radius, y - radius * circleApproximationConst), new Point2D.Double(x + radius * circleApproximationConst, y - radius), new Point2D.Double(x, y - radius) })); approximation[2] = new BezierCurve(new List<Point2D>(new Point2D[] { new Point2D.Double(x, y - radius), new Point2D.Double(x - radius * circleApproximationConst, y - radius), new Point2D.Double(x - radius, y - radius * circleApproximationConst), new Point2D.Double(x - radius, y) })); approximation[3] = new BezierCurve(new List<Point2D>(new Point2D[] { new Point2D.Double(x - radius, y), new Point2D.Double(x - radius, y + radius * circleApproximationConst), new Point2D.Double(x - radius * circleApproximationConst, y + radius), new Point2D.Double(x, y + radius) })); return approximation; }
internal bool Contains(Point2D point) { return Util.compare(Math.Abs(A * (float) point.GetX() + B * (float) point.GetY() + C), 0.1f) < 0; }
private static void AddRect(Clipper clipper, Point2D[] rectVertices, PolyType polyType) { clipper.AddPath(ConvertToIntPoints(new List<Point2D>(rectVertices)), polyType, true); }
/** * Constructs a new line based on the given coordinates. */ public Line(float x1, float y1, float x2, float y2) { p1 = new Point2D.Float(x1, y1); p2 = new Point2D.Float(x2, y2); }
private bool Intersect(Point2D[] rect1, Point2D[] rect2) { Clipper clipper = new Clipper(); AddRect(clipper, rect1, PolyType.ptSubject); AddRect(clipper, rect2, PolyType.ptClip); List<List<IntPoint>> paths = new List<List<IntPoint>>(); clipper.Execute(ClipType.ctIntersection, paths, PolyFillType.pftNonZero, PolyFillType.pftNonZero); return paths.Count != 0; }
virtual public double Distance(Point2D p) { return Math.Sqrt(DistanceSq(p)); }
private Rectangle GetRectangle(Point2D p1, Point2D p2, Point2D p3, Point2D p4) { double[] xs = { p1.GetX(), p2.GetX(), p3.GetX(), p4.GetX() }; double[] ys = { p1.GetY(), p2.GetY(), p3.GetY(), p4.GetY() }; double left = Util.Min(xs); double bottom = Util.Min(ys); double right = Util.Max(xs); double top = Util.Max(ys); return new Rectangle((float)left, (float)bottom, (float)right, (float)top); }
virtual public double DistanceSq(Point2D p) { return Point2D.DistanceSq(GetX(), GetY(), p.GetX(), p.GetY()); }
private static Point2D GetNextPoint(Point2D segStart, Point2D segEnd, float dist) { Point2D vector = ComponentwiseDiff(segEnd, segStart); Point2D unitVector = GetUnitVector(vector); return new Point2D.Float((float) (segStart.GetX() + dist * unitVector.GetX()), (float) (segStart.GetY() + dist * unitVector.GetY())); }