Vector2D

java.lang.Object
- org.mdiutil.geom.Vector2D

All Implemented Interfaces:

Cloneable
```
public class Vector2D
extends Object
implements Cloneable
```
This class represents a 2D Vector.
It offers several utility methods to manage vectors :
- normalization, angle, product of a vector by a scalar
- rotation of a vector, perpendicular vector
- addition, soustraction, scalar product of two vectors
- intersection between two lines defined by a point and a vector
- projection of a point on a line defined by this vector and an origin point
- determination if two lines are colinear
- result of an affine transformation

Field Summary

Fields
Modifier and Type	Field and Description
`static double`	`ASSUME_ANGLE_ZERO` 0.017: Constant used for angles equality.
`static double`	`ASSUME_ZERO` 1.0E-4: Constant used for coordinates equality.
`double`	`x` The x coordinate of the Vector.
`double`	`y` The y coordinate of the Vector.

Constructor Summary

Constructors
Constructor and Description
`Vector2D()` Create a (0, 0) 2D Vector.
`Vector2D(double x, double y)` Create a 2D Vector, knowing its x and y coordinates.
`Vector2D(Point2D p0, Point2D p1)` Create a 2D Vector, knowing its two associated points.
`Vector2D(Vector2D v)` Create a 2D Vector, identical to another Vector2D.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`Vector2D`	`add(Vector2D v)` Adds another Vector to this one.
`Object`	`clone()`
`double`	`getAngle()` Return the angle of this vector with the X axis.
`Point2D`	`getIntersection(Point2D p0, Vector2D v1, Point2D p1)` Find the intersection between two lines.
`Vector2D`	`getInverse()` Return the inverse of this Vector, which is this vector rotated by PI.
`double`	`getNorm()` Return the euclidian norm of this Vector.
`Vector2D`	`getNormal()` Return the normal of this vector.
`Point2D`	`getNormalProjection(Point2D o, Point2D p)` Return the orthogonal projection of this point on the line defined by the Vector2D.
`double`	`getScalarProduct(Vector2D v)` Return the scalar product of this vector with another vector.
`double`	`getX()` Return the X coordinate of this Vector.
`double`	`getY()` Return the Y coordinate of this Vector.
`boolean`	`isColinear(Point2D p0, Vector2D v1, Point2D p1)` Determines if two lines are colinear.
`boolean`	`isColinear(Point2D p0, Vector2D v1, Point2D p1, double delta, double deltaAngle)` Determines if two lines are colinear.
`Vector2D`	`minus(Vector2D v)` Substracts another vector from this one.
`Vector2D`	`normalize()` Normalize this vector.
`Vector2D`	`rotate(double alpha)` Rotates the Vector.
`Vector2D`	`scaleTo(double d)` Multiply the coordinates of this Vector by a scalar value.
`void`	`setX(double x)` Set the X coordinate of this Vector.
`void`	`setY(double y)` Set the Y coordinate of this Vector.
`Vector2D`	`transform(AffineTransform tr)` Return the Vector2D after an AffineTransform.
`static Point2D`	`transform(Point2D p, AffineTransform tr)` Return a Point2D transformed after an affine transformation.
`Point2D`	`translate(Point2D p)` Translate a Point by this vector.

Methods inherited from class java.lang.Object
equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - x
```
public double x
```
    The x coordinate of the Vector.
  - y
```
public double y
```
    The y coordinate of the Vector.
  - ASSUME_ZERO
```
public static final double ASSUME_ZERO
```
    1.0E-4: Constant used for coordinates equality. Its value is 0.0001.
    
    See Also:
    
    Constant Field Values
  - ASSUME_ANGLE_ZERO
```
public static final double ASSUME_ANGLE_ZERO
```
    0.017: Constant used for angles equality. Its value is approximately equal to 1 degree expressed in radians (0.017 radians).
    
    See Also:
    
    Constant Field Values
- Constructor Detail
  - Vector2D
```
public Vector2D()
```
    Create a (0, 0) 2D Vector.
  - Vector2D
```
public Vector2D(double x,
                double y)
```
    Create a 2D Vector, knowing its x and y coordinates.
    
    Parameters:
    
    x - the x coordinate
    
    y - the y coordinate
  - Vector2D
```
public Vector2D(Point2D p0,
                Point2D p1)
```
    Create a 2D Vector, knowing its two associated points.
    
    Parameters:
    
    p0 - the first point
    
    p1 - the second point
  - Vector2D
```
public Vector2D(Vector2D v)
```
    Create a 2D Vector, identical to another Vector2D.
    
    Parameters:
    
    v - the vector to clone
- Method Detail
  - getX
```
public double getX()
```
    Return the X coordinate of this Vector.
    
    Returns:
    
    the X coordinate
  - getY
```
public double getY()
```
    Return the Y coordinate of this Vector.
    
    Returns:
    
    the Y coordinate
  - setX
```
public void setX(double x)
```
    Set the X coordinate of this Vector.
    
    Parameters:
    
    x - the X coordinate
  - setY
```
public void setY(double y)
```
    Set the Y coordinate of this Vector.
    
    Parameters:
    
    y - the Y coordinate
  - getScalarProduct
```
public double getScalarProduct(Vector2D v)
```
    Return the scalar product of this vector with another vector.
    
    Parameters:
    
    v - the other Vector
    
    Returns:
    
    the scalar product
  - minus
```
public Vector2D minus(Vector2D v)
```
    Substracts another vector from this one.
    
    Parameters:
    
    v - the other Vector
    
    Returns:
    
    a new vector which is the result of the substraction
  - rotate
```
public Vector2D rotate(double alpha)
```
    Rotates the Vector.
    
    Parameters:
    
    alpha - the angle in Radians
    
    Returns:
    
    a new vector which is the result of the rotation
  - add
```
public Vector2D add(Vector2D v)
```
    Adds another Vector to this one.
    
    Parameters:
    
    v - the other Vector
    
    Returns:
    
    a new Vector which is the result of the addition
  - getNorm
```
public double getNorm()
```
    Return the euclidian norm of this Vector.
    
    Returns:
    
    the euclidian norm of this Vector
  - getAngle
```
public double getAngle()
```
    Return the angle of this vector with the X axis. The angle is in the range of -pi to pi (using Math.atan2 formula)
    
    Returns:
    
    the angle in Radians
  - normalize
```
public Vector2D normalize()
```
    Normalize this vector. If this vector has a zero norm, then the normalized vector will be the (0, 0) vector.
    
    Returns:
    
    a new vector which is the result of the normalization
  - scaleTo
```
public Vector2D scaleTo(double d)
```
    Multiply the coordinates of this Vector by a scalar value.
    
    Parameters:
    
    d - the factor
    
    Returns:
    
    a new Vector which is the result of the multiplication
  - translate
```
public Point2D translate(Point2D p)
```
    Translate a Point by this vector.
    
    Parameters:
    
    p - the Point
    
    Returns:
    
    the translated Point
  - getNormal
```
public Vector2D getNormal()
```
    Return the normal of this vector. If this vector has a zero norm, then the normal will be the (0, 0) vector, else it will have a unit norm.
    
    Returns:
    
    the normal Vector
  - getInverse
```
public Vector2D getInverse()
```
    Return the inverse of this Vector, which is this vector rotated by PI.
    
    Returns:
    
    the inverse of this Vector
  - getNormalProjection
```
public Point2D getNormalProjection(Point2D o,
                                   Point2D p)
```
    Return the orthogonal projection of this point on the line defined by the Vector2D. If this vector has a zero norm, then the projection will be the initial point.
    
    Parameters:
    
    o - the origin of the line
    
    p - the point to project
    
    Returns:
    
    the orthogonal projection of p
  - isColinear
```
public boolean isColinear(Point2D p0,
                          Vector2D v1,
                          Point2D p1,
                          double delta,
                          double deltaAngle)
```
    Determines if two lines are colinear. The two lines are :
    - the line defined by the point p0 and this Vector2D
    - the line defined by the point p1 and the Vector2D v1
    The two lines are considered colinear if :
    - the distance between the projection of p1 on the line defined by p0 and this Vector2D, and the point p1, is less than delta
    - the difference between the angles of the two vectors are less than delta_angle
    Parameters:
    
    p0 - origin of the first line (defined by this vector)
    
    v1 - vector defining the second line
    
    p1 - origin of the second line
    
    delta - the delta concerning the distance of p1 to the first line
    
    deltaAngle - the delta concerning the difference between the two angles
    
    Returns:
    
    true if the two lines are colinear
  - isColinear
```
public boolean isColinear(Point2D p0,
                          Vector2D v1,
                          Point2D p1)
```
    Determines if two lines are colinear.
    Same as {link #isColinear(Point2D, Vector2D, Point2D, double, double)} where :
    - the delta parameter is equal to ASSUME_ZERO
    - the delta_angle parameter is equal to ASSUME_ANGLE_ZERO
    Parameters:
    
    p0 - origin of the first line (defined by this vector)
    
    v1 - vector defining the second line
    
    p1 - origin of the second line
    
    Returns:
    
    true if the two lines are colinear
  - getIntersection
```
public Point2D getIntersection(Point2D p0,
                               Vector2D v1,
                               Point2D p1)
```
    Find the intersection between two lines. The two lines are:
    - the line defined by the point p0 and this Vector2D
    - the line defined by the point p1 and the Vector2D v1
    It is considered that there is no intersection if either :
    - the two x coordinates are closer from 0 than the ASSUME_ZERO value
    - the two x coordinates are farther from 0 than the ASSUME_ZERO value, but they differ from less than this value
    Remark: The intersection is computed by resolving the following equations:
    - y = a0 * x + b0
    - y = a1 * x + b1
    where :
    - the first (a0, b0) line is defined by this Vector2D and the point p0
    - the second (a1, b1) line is defined by the Vector2D v1 and the point p1
    Parameters:
    
    p0 - origin of the first line (defined by this vector)
    
    v1 - vector defining the second line
    
    p1 - origin of the second line
    
    Returns:
    
    the intersection Point
  - clone
```
public Object clone()
```
    Overrides:
    
    clone in class Object
  - transform
```
public Vector2D transform(AffineTransform tr)
```
    Return the Vector2D after an AffineTransform.
    
    Parameters:
    
    tr - the AffineTransform
    
    Returns:
    
    a new Vector2D which is the result of the AffineTransform by tr
  - transform
```
public static Point2D transform(Point2D p,
                                AffineTransform tr)
```
    Return a Point2D transformed after an affine transformation.
    
    Parameters:
    
    p - the point
    
    tr - the AffineTransform
    
    Returns:
    
    a Point2D which is the result of the AffineTransform of p by tr

Class Vector2D

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

x

y

ASSUME_ZERO

ASSUME_ANGLE_ZERO

Constructor Detail

Vector2D

Vector2D

Vector2D

Vector2D

Method Detail

getX

getY

setX

setY

getScalarProduct

minus

rotate

add

getNorm

getAngle

normalize

scaleTo

translate

getNormal

getInverse

getNormalProjection

isColinear

isColinear

getIntersection

clone

transform

transform