/**
* 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()));
}
