Line2D

Overview

Package

Class

Use

Tree

Deprecated

Index

Help

PREV CLASS NEXT CLASS

FRAMES NO FRAMES All Classes

SUMMARY: NESTED | FIELD | CONSTR | METHOD

DETAIL: FIELD | CONSTR | METHOD

math.geom2d.line
Class Line2D

java.lang.Object
  math.geom2d.curve.AbstractContinuousCurve2D
      math.geom2d.curve.AbstractSmoothCurve2D
          math.geom2d.line.Line2D

All Implemented Interfaces:: java.lang.Cloneable, CirculinearContinuousCurve2D, CirculinearCurve2D, CirculinearElement2D, CirculinearShape2D, ContinuousCurve2D, Curve2D, SmoothCurve2D, ContinuousOrientedCurve2D, OrientedCurve2D, SmoothOrientedCurve2D, GeometricObject2D, LinearElement2D, LinearShape2D, Shape2D

public class Line2D
extends AbstractSmoothCurve2D
implements LinearElement2D, java.lang.Cloneable
extends AbstractSmoothCurve2D
implements LinearElement2D, java.lang.Cloneable

Line object defined from 2 points. This object keep points reference in memory, and recomputes properties directly from points. Line2D is mutable.

Example :

// Create an Edge2D Line2D line = new Line2D(new Point2D(0, 0), new Point2D(1, 2)); // Change direction of line, by changing second point : line.setPoint2(new Point2D(4, 5)); // Change position and direction of the line, by changing first point. // 'line' is now the edge (2,3)-(4,5) line.setPoint1(new Point2D(2, 3));

This class may be slower than Edge2D or StraightLine2D, because parameters are updated each time a computation is made, causing lot of additional processing. Moreover, as inner point fields are public, it is not as safe as LineSegment2D.

Field Summary
`Point2D`	`p1` The origin point.
`Point2D`	`p2` The destination point.

Fields inherited from interface math.geom2d.Shape2D
`ACCURACY`

Constructor Summary
`Line2D(double x1, double y1, double x2, double y2)` Define a new Line2D with two extremities.
`Line2D(Point2D point1, Point2D point2)` Define a new Line2D with two extremities.

Method Summary
`boolean`	`almostEquals(GeometricObject2D obj, double eps)` Checks if the two objects are similar up to a given threshold value.
`java.awt.geom.GeneralPath`	`appendPath(java.awt.geom.GeneralPath path)` Append the path of the curve to the given path.
`Box2D`	`boundingBox()` Returns the bounding box of the Line2D.
`CirculinearDomain2D`	`buffer(double dist)` Computes the buffer of the shape, formed by the set of points located at a distance from the shape that is lower or equal to d.
`double[]`	`cartesianEquation()`
`CurveSet2D<? extends Line2D>`	`clip(Box2D box)` Clips the line object by a box.
`Line2D`	`clone()` Overrides Object declaration to ensure Curve2D implementation are cloned as Curve2D.
`boolean`	`contains(double x, double y)` Returns true if the point (x, y) lies on the line, with precision given by Shape2D.ACCURACY.
`boolean`	`contains(Point2D p)` Returns true if the point p lies on the line, with precision given by Shape2D.ACCURACY.
`java.util.Collection<? extends Line2D>`	`continuousCurves()` Returns the collection of continuous curves which constitute this curve.
`static Line2D`	`create(Point2D p1, Point2D p2)` Deprecated. since 0.11.1
`double`	`curvature(double t)` Returns 0 as every linear shape.
`Vector2D`	`direction()` Return one direction vector of the linear shape.
`double`	`distance(double x, double y)` Returns the distance of the point (x, y) to this edge.
`double`	`distance(Point2D p)` Returns the distance of the point `p` to this edge.
`boolean`	`equals(java.lang.Object obj)` Two Line2D are equals if the share the two same points, in the same order.
`Point2D`	`firstPoint()` Get the first point of the curve.
`java.awt.geom.GeneralPath`	`getGeneralPath()`
`Point2D`	`getOtherPoint(Point2D point)` Return the opposite vertex of the edge.
`Point2D`	`getPoint1()` Return the first point of the edge.
`Point2D`	`getPoint2()` Return the last point of the edge.
`double`	`getT0()` Deprecated. replaced by t0() (since 0.11.1).
`double`	`getT1()` Deprecated. replaced by t1() (since 0.11.1).
`double`	`getX1()`
`double`	`getX2()`
`double`	`getY1()`
`double`	`getY2()`
`double`	`horizontalAngle()` Returns the angle with axis (O,i), counted counter-clockwise.
`Point2D`	`intersection(LinearShape2D line)` Returns the unique intersection with a linear shape.
`java.util.Collection<Point2D>`	`intersections(LinearShape2D line)` Returns the intersection points of the curve with the specified line.
`static boolean`	`intersects(Line2D line1, Line2D line2)` Checks if two line intersect.
`boolean`	`isBounded()` Returns true
`boolean`	`isClosed()` Returns false.
`boolean`	`isColinear(LinearShape2D line)`
`boolean`	`isEmpty()` Returns false
`boolean`	`isInside(Point2D point)` Returns true if the point is 'inside' the domain bounded by the curve.
`boolean`	`isParallel(LinearShape2D line)` Test if the this object is parallel to the given one.
`Point2D`	`lastPoint()` Get the last point of the curve.
`double`	`length()`
`double`	`length(double pos)`
`Point2D`	`origin()` Returns a point in the linear shape.
`Line2D`	`parallel(double d)` Creates a new curve, formed by the points with parameterization: `p(t) = c(t) + d*n(t)/\|n(t)\|`, with p(t) being a point of the original curve, n(t) the normal of the curve, and \|n\| being the norm of n.
`StraightLine2D`	`parallel(Point2D point)` Creates a straight line parallel to this object, and passing through the given point.
`double[][]`	`parametric()`
`StraightLine2D`	`perpendicular(Point2D point)` Creates a straight line perpendicular to this object, and passing through the given point.
`Point2D`	`point(double t)` Returns the point located at the given position on the curve.
`double[]`	`polarCoefficients()`
`double[]`	`polarCoefficientsSigned()`
`double`	`position(double length)`
`double`	`position(Point2D point)` Returns the position of the point on the line.
`double`	`project(Point2D point)` Returns the position of the closest orthogonal projection of the point on the curve, or of the closest singular point.
`Line2D`	`reverse()` Returns the Line2D object which starts at `point2` and ends at `point1`.
`void`	`setPoint1(Point2D point)`
`void`	`setPoint2(Point2D point)`
`double`	`signedDistance(double x, double y)` The same as distanceSigned(Point2D), but by passing 2 double as arguments.
`double`	`signedDistance(Point2D p)` Returns the signed distance of the curve to the given point.
`java.util.Collection<? extends Line2D>`	`smoothPieces()` Returns a set of smooth curves.
`Line2D`	`subCurve(double t0, double t1)` Returns a new Line2D, which is the portion of the line delimited by parameters t0 and t1.
`StraightLine2D`	`supportingLine()` Returns the straight line that contains this linear shape.
`double`	`t0()` Returns 0.
`double`	`t1()` Returns 1.
`Vector2D`	`tangent(double t)` Returns the tangent of the curve at the given position.
`java.lang.String`	`toString()`
`Line2D`	`transform(AffineTransform2D trans)` Transforms the shape by an affine transform.
`CirculinearElement2D`	`transform(CircleInversion2D inv)` Transforms the shape by a circle inversion.
`double`	`windingAngle(Point2D point)` Return the angle portion that the curve turn around the given point.

Methods inherited from class math.geom2d.curve.AbstractSmoothCurve2D
`isSingular, leftTangent, normal, rightTangent, singularPoints, vertices`

Methods inherited from class math.geom2d.curve.AbstractContinuousCurve2D
`asAwtShape, asPolyline, draw`

Methods inherited from class java.lang.Object
`getClass, hashCode, notify, notifyAll, wait, wait, wait`

Methods inherited from interface math.geom2d.curve.SmoothCurve2D
`normal`

Methods inherited from interface math.geom2d.curve.ContinuousCurve2D
`asPolyline, leftTangent, rightTangent`

Methods inherited from interface math.geom2d.curve.Curve2D
`asAwtShape, draw, isSingular, singularPoints, vertices`

Field Detail

p1

public Point2D p1

The origin point.

p2

public Point2D p2

The destination point.

Constructor Detail

Line2D

public Line2D(Point2D point1,
              Point2D point2)

Define a new Line2D with two extremities.

Line2D

public Line2D(double x1,
              double y1,
              double x2,
              double y2)

Define a new Line2D with two extremities.

Method Detail

intersects

public static boolean intersects(Line2D line1,
                                 Line2D line2)

Checks if two line intersect. Uses the Point2D.ccw method, which is based on Sedgewick algorithm.

Parameters:: line1 - a Line2D object; line2 - a Line2D object
Returns:: true if the 2 lines intersect

create

@Deprecated
public static Line2D create(Point2D p1,
                                       Point2D p2)

Deprecated. since 0.11.1

Static factory for creating a new Line2D, starting from p1 and finishing at p2.

getPoint1

public Point2D getPoint1()

Return the first point of the edge. It corresponds to getPoint(0).

Returns:: the first point.

getPoint2

public Point2D getPoint2()

Return the last point of the edge. It corresponds to getPoint(1).

Returns:: the last point.

getX1

public double getX1()

getY1

public double getY1()

getX2

public double getX2()

getY2

public double getY2()

getOtherPoint

public Point2D getOtherPoint(Point2D point)

Return the opposite vertex of the edge.

Parameters:: point - : one of the vertices of the edge
Returns:: the other vertex

setPoint1

public void setPoint1(Point2D point)

setPoint2

public void setPoint2(Point2D point)

isColinear

public boolean isColinear(LinearShape2D line)

isParallel

public boolean isParallel(LinearShape2D line)

Test if the this object is parallel to the given one. This method is overloaded to update parameters before computation.

buffer

public CirculinearDomain2D buffer(double dist)

Description copied from interface: CirculinearShape2D

Computes the buffer of the shape, formed by the set of points located at a distance from the shape that is lower or equal to d.

Specified by:: buffer in interface CirculinearShape2D

Parameters:: dist - the maximal distance between a point of the buffer and the shape
Returns:: the buffer of the shape

parallel

public Line2D parallel(double d)

Description copied from interface: CirculinearCurve2D

Creates a new curve, formed by the points with parameterization: p(t) = c(t) + d*n(t)/|n(t)|, with p(t) being a point of the original curve, n(t) the normal of the curve, and |n| being the norm of n.
In the case of a continuous curve formed by several smooth circulinear elements, the parallels of contiguous elements are joined by a circle arc.

Specified by:: parallel in interface CirculinearContinuousCurve2D
Specified by:: parallel in interface CirculinearCurve2D
Specified by:: parallel in interface CirculinearElement2D

Parameters:: d - the distance between the original curve and he parallel curve.
Returns:: the parallel curve

length

public double length()

Specified by:: length in interface CirculinearCurve2D

Returns:: the length of the curve

length

public double length(double pos)

Specified by:: length in interface CirculinearCurve2D

Returns:: the length from the beginning to the position given by pos

position

public double position(double length)

Specified by:: position in interface CirculinearCurve2D

Returns:: the position located at a given geodesic distance from the origin

transform

public CirculinearElement2D transform(CircleInversion2D inv)

Description copied from interface: CirculinearShape2D

Transforms the shape by a circle inversion. The result is still an instance a CirculinearShape2D.

Specified by:: transform in interface CirculinearContinuousCurve2D
Specified by:: transform in interface CirculinearCurve2D
Specified by:: transform in interface CirculinearElement2D
Specified by:: transform in interface CirculinearShape2D

Parameters:: inv - the circle inversion
Returns:: the transformed shape

parametric

public double[][] parametric()

cartesianEquation

public double[] cartesianEquation()

polarCoefficients

public double[] polarCoefficients()