Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## toxi.geom
Interface ReadonlyVec2D

All Known Implementing Classes:
  Circle, Ellipse, Ray2D, Vec2D

    public interface ReadonlyVec2D

Readonly, immutable interface wrapper for Vec2D instances. Used throughout the library for safety purposes.

Method Summary
`Vec2D` | `add(float a, float b)` Adds vector {a,b,c} and returns result as new vector.
`Vec2D` | `add(ReadonlyVec2D v)` Add vector v and returns result as new vector.
`float` | `angleBetween(ReadonlyVec2D v)` Computes the angle between this vector and vector V.
`float` | `angleBetween(ReadonlyVec2D v, boolean forceNormalize)` Computes the angle between this vector and vector V
`Vec3D` | `bisect(Vec2D p)` Computes the perpendicular bisector of two points.
`int` | `compareTo(ReadonlyVec2D v)` Compares the length of the vector with another one.
`Vec2D` | `copy()`
`float` | `cross(ReadonlyVec2D v)` Calculates the cross-product with the given vector.
`float` | `distanceTo(ReadonlyVec2D v)` Calculates distance to another vector
`float` | `distanceToSquared(ReadonlyVec2D v)` Calculates the squared distance to another vector
`float` | `dot(ReadonlyVec2D v)` Computes the scalar product (dot product) with the given vector.
`boolean` | `equals(java.lang.Object obj)`
`boolean` | `equalsWithTolerance(ReadonlyVec2D v, float tolerance)` Compares this vector with the one given.
`Vec2D` | `getAbs()`
`float` | `getComponent(int id)`
`float` | `getComponent(Vec2D.Axis id)`
`Vec2D` | `getConstrained(Rect r)` Creates a copy of the vector which forcefully fits in the given rectangle.
`Vec2D` | `getFloored()` Creates a new vector whose components are the integer value of their current values
`Vec2D` | `getFrac()` Creates a new vector whose components are the fractional part of their current values
`Vec2D` | `getInverted()` Scales vector uniformly by factor -1 ( v = -v )
`Vec2D` | `getLimited(float lim)` Creates a copy of the vector with its magnitude limited to the length given
`Vec2D` | `getNormalized()` Produces the normalized version as a new vector
`Vec2D` | `getNormalizedTo(float len)` Produces a new vector normalized to the given length.
`Vec2D` | `getPerpendicular()`
`Vec2D` | `getReciprocal()`
`Vec2D` | `getReflected(ReadonlyVec2D normal)`
`Vec2D` | `getRotated(float theta)` Creates a new vector rotated by the given angle around the Z axis.
`Vec2D` | `getSignum()` Creates a new vector in which all components are replaced with the signum of their original values.
`float` | `heading()` Computes the vector's direction in the XY plane (for example for 2D points).
`Vec2D` | `interpolateTo(ReadonlyVec2D v, float f)` Interpolates the vector towards the given target vector, using linear interpolation
`Vec2D` | `interpolateTo(ReadonlyVec2D v, float f, InterpolateStrategy s)` Interpolates the vector towards the given target vector, using the given `InterpolateStrategy`
`boolean` | `isInCircle(ReadonlyVec2D sO, float sR)` Checks if the point is inside the given sphere.
`boolean` | `isInRectangle(Rect r)` Checks if the point is inside the given rectangle.
`boolean` | `isInTriangle(Vec2D a, Vec2D b, Vec2D c)` Checks if point vector is inside the triangle created by the points a, b and c.
`boolean` | `isMajorAxis(float tolerance)` Checks if the vector is parallel with either the X or Y axis (any direction).
`boolean` | `isZeroVector()` Checks if vector has a magnitude equals or close to zero (tolerance used is `MathUtils.EPS`).
`float` | `magnitude()` Calculates the magnitude/eucledian length of the vector
`float` | `magSquared()` Calculates only the squared magnitude/length of the vector.
`Vec2D` | `max(Vec2D v)` Constructs a new vector consisting of the largest components of both vectors.
`Vec2D` | `min(Vec2D v)` Constructs a new vector consisting of the smallest components of both vectors.
`Vec2D` | `scale(float s)` Scales vector uniformly and returns result as new vector.
`Vec2D` | `scale(float a, float b)` Scales vector non-uniformly and returns result as new vector.
`Vec2D` | `scale(ReadonlyVec2D s)`
`Vec2D` | `scale(Vec2D s)` Scales vector non-uniformly by vector v and returns result as new vector
`Vec2D` | `sub(float a, float b)` Subtracts vector {a,b,c} and returns result as new vector.
`Vec2D` | `sub(ReadonlyVec2D v)`
`Vec2D` | `sub(Vec2D v)` Subtracts vector v and returns result as new vector.
`Vec2D` | `tangentNormalOfEllipse(Vec2D eO, Vec2D eR)` Calculates the normal vector on the given ellipse in the direction of the current point.
`Vec3D` | `to3DXY()` Creates a 3D version of this vector in the XY plane.
`Vec3D` | `to3DXZ()` Creates a 3D version of this vector in the XZ plane.
`Vec3D` | `to3DYZ()` Creates a 3D version of this vector in the YZ plane.
`float[]` | `toArray()`
`Vec2D` | `toCartesian()` Converts the vector from polar to Cartesian space.
`Vec2D` | `toPolar()` Converts the current vector into polar coordinates.
`float` | `x()`
`float` | `y()`

Method Detail

### add

    Vec2D add(float a,
              float b)

  Adds vector {a,b,c} and returns result as new vector.

  Parameters:
    `a` - X coordinate
    `b` - Y coordinate
  Returns:
    result as new vector

### add

    Vec2D add(ReadonlyVec2D v)

  Add vector v and returns result as new vector.

  Parameters:
    `v` - vector to add
  Returns:
    result as new vector

### angleBetween

    float angleBetween(ReadonlyVec2D v)

  Computes the angle between this vector and vector V. This function assumes both vectors are normalized, if this can't be guaranteed, use the alternative implementation `angleBetween(ReadonlyVec2D, boolean)`

  Parameters:
    `v` - vector
  Returns:
    angle in radians, or NaN if vectors are parallel

### angleBetween

    float angleBetween(ReadonlyVec2D v,
                       boolean forceNormalize)

  Computes the angle between this vector and vector V

  Parameters:
    `v` - vector
    `forceNormalize` - true, if normalized versions of the vectors are to be used (Note: only copies will be used, original vectors will not be altered by this method)
  Returns:
    angle in radians, or NaN if vectors are parallel

### bisect

    Vec3D bisect(Vec2D p)

  Computes the perpendicular bisector of two points.

  Parameters:
    `p` - other point
  Returns:
    bisector coefficients as `Vec3D`

### compareTo

    int compareTo(ReadonlyVec2D v)

  Compares the length of the vector with another one.

  Parameters:
    `v` - vector to compare with
  Returns:
    -1 if other vector is longer, 0 if both are equal or else +1

### copy

    Vec2D copy()

  Returns:
    a new independent instance/copy of a given vector

### cross

    float cross(ReadonlyVec2D v)

  Calculates the cross-product with the given vector.

  Parameters:
    `v` - vector
  Returns:
    the magnitude of the vector that would result from a regular 3D cross product of the input vectors, taking their Z values implicitly as 0 (i.e. treating the 2D space as a plane in the 3D space). The 3D cross product will be perpendicular to that plane, and thus have 0 X & Y components (thus the scalar returned is the Z value of the 3D cross product vector).
  See Also:
    Stackoverflow entry

### distanceTo

    float distanceTo(ReadonlyVec2D v)

  Calculates distance to another vector

  Parameters:
    `v` - non-null vector
  Returns:
    distance or Float.NaN if v=null

### distanceToSquared

    float distanceToSquared(ReadonlyVec2D v)

  Calculates the squared distance to another vector

  Parameters:
    `v` - non-null vector
  Returns:
    distance or NaN if v=null
  See Also:
    `magSquared()`

### dot

    float dot(ReadonlyVec2D v)

  Computes the scalar product (dot product) with the given vector.

  Parameters:
    `v` -
  Returns:
    dot product
  See Also:
    Wikipedia entry< /a>

### equals

    boolean equals(java.lang.Object obj)

  Overrides:
    `equals` in class `java.lang.Object`

### equalsWithTolerance

    boolean equalsWithTolerance(ReadonlyVec2D v,
                                float tolerance)

  Compares this vector with the one given. The vectors are deemed equal if the individual differences of all component values are within the given tolerance.

  Parameters:
    `v` - the v
    `tolerance` - the tolerance
  Returns:
    true, if equal

### getAbs

    Vec2D getAbs()

### getComponent

    float getComponent(Vec2D.Axis id)

### getComponent

    float getComponent(int id)

### getConstrained

    Vec2D getConstrained(Rect r)

  Creates a copy of the vector which forcefully fits in the given rectangle.

  Parameters:
    `r` -
  Returns:
    fitted vector

### getFloored

    Vec2D getFloored()

  Creates a new vector whose components are the integer value of their current values

  Returns:
    result as new vector

### getFrac

    Vec2D getFrac()

  Creates a new vector whose components are the fractional part of their current values

  Returns:
    result as new vector

### getInverted

    Vec2D getInverted()

  Scales vector uniformly by factor -1 ( v = -v )

  Returns:
    result as new vector

### getLimited

    Vec2D getLimited(float lim)

  Creates a copy of the vector with its magnitude limited to the length given

  Parameters:
    `lim` - new maximum magnitude
  Returns:
    result as new vector

### getNormalized

    Vec2D getNormalized()

  Produces the normalized version as a new vector

  Returns:
    new vector

### getNormalizedTo

    Vec2D getNormalizedTo(float len)

  Produces a new vector normalized to the given length.

  Parameters:
    `len` - new desired length
  Returns:
    new vector

### getPerpendicular

    Vec2D getPerpendicular()

### getReciprocal

    Vec2D getReciprocal()

### getReflected

    Vec2D getReflected(ReadonlyVec2D normal)

### getRotated

    Vec2D getRotated(float theta)

  Creates a new vector rotated by the given angle around the Z axis.

  Parameters:
    `theta` -
  Returns:
    rotated vector

### getSignum

    Vec2D getSignum()

  Creates a new vector in which all components are replaced with the signum of their original values. In other words if a components value was negative its new value will be -1, if zero => 0, if positive => +1

  Returns:
    result vector

### heading

    float heading()

  Computes the vector's direction in the XY plane (for example for 2D points). The positive X axis equals 0 degrees.

  Returns:
    rotation angle

### interpolateTo

    Vec2D interpolateTo(ReadonlyVec2D v,
                        float f)

  Interpolates the vector towards the given target vector, using linear interpolation

  Parameters:
    `v` - target vector
    `f` - interpolation factor (should be in the range 0..1)
  Returns:
    result as new vector

### interpolateTo

    Vec2D interpolateTo(ReadonlyVec2D v,
                        float f,
                        InterpolateStrategy s)

  Interpolates the vector towards the given target vector, using the given `InterpolateStrategy`

  Parameters:
    `v` - target vector
    `f` - interpolation factor (should be in the range 0..1)
    `s` - InterpolateStrategy instance
  Returns:
    result as new vector

### isInCircle

    boolean isInCircle(ReadonlyVec2D sO,
                       float sR)

  Checks if the point is inside the given sphere.

  Parameters:
    `sO` - circle origin/centre
    `sR` - circle radius
  Returns:
    true, if point is in sphere

### isInRectangle

    boolean isInRectangle(Rect r)

  Checks if the point is inside the given rectangle.

  Parameters:
    `r` - bounding rectangle
  Returns:
    true, if point is inside

### isInTriangle

    boolean isInTriangle(Vec2D a,
                         Vec2D b,
                         Vec2D c)

  Checks if point vector is inside the triangle created by the points a, b and c. These points will create a plane and the point checked will have to be on this plane in the region between a,b,c. Note: The triangle must be defined in clockwise order a,b,c

  Returns:
    true, if point is in triangle.

### isMajorAxis

    boolean isMajorAxis(float tolerance)

  Checks if the vector is parallel with either the X or Y axis (any direction).

  Parameters:
    `tolerance` -
  Returns:
    true, if parallel within the given tolerance

### isZeroVector

    boolean isZeroVector()

  Checks if vector has a magnitude equals or close to zero (tolerance used is `MathUtils.EPS`).

  Returns:
    true, if zero vector

### magnitude

    float magnitude()

  Calculates the magnitude/eucledian length of the vector

  Returns:
    vector length

### magSquared

    float magSquared()

  Calculates only the squared magnitude/length of the vector. Useful for inverse square law applications and/or for speed reasons or if the real eucledian distance is not required (e.g. sorting). Please note the vector should contain cartesian (not polar) coordinates in order for this function to work. The magnitude of polar vectors is stored in the x component.

  Returns:
    squared magnitude (x^2 + y^2)

### max

    Vec2D max(Vec2D v)

  Constructs a new vector consisting of the largest components of both vectors.

  Parameters:
    `v` -
  Returns:
    result as new vector

### min

    Vec2D min(Vec2D v)

  Constructs a new vector consisting of the smallest components of both vectors.

  Parameters:
    `v` - comparing vector
  Returns:
    result as new vector

### scale

    Vec2D scale(float s)

  Scales vector uniformly and returns result as new vector.

  Parameters:
    `s` - scale factor
  Returns:
    new vector

### scale

    Vec2D scale(float a,
                float b)

  Scales vector non-uniformly and returns result as new vector.

  Parameters:
    `a` - scale factor for X coordinate
    `b` - scale factor for Y coordinate
  Returns:
    new vector

### scale

    Vec2D scale(ReadonlyVec2D s)

### scale

    Vec2D scale(Vec2D s)

  Scales vector non-uniformly by vector v and returns result as new vector

  Parameters:
    `s` - scale vector
  Returns:
    new vector

### sub

    Vec2D sub(float a,
              float b)

  Subtracts vector {a,b,c} and returns result as new vector.

  Parameters:
    `a` - X coordinate
    `b` - Y coordinate
  Returns:
    result as new vector

### sub

    Vec2D sub(ReadonlyVec2D v)

### sub

    Vec2D sub(Vec2D v)

  Subtracts vector v and returns result as new vector.

  Parameters:
    `v` - vector to be subtracted
  Returns:
    result as new vector

### tangentNormalOfEllipse

    Vec2D tangentNormalOfEllipse(Vec2D eO,
                                 Vec2D eR)

  Calculates the normal vector on the given ellipse in the direction of the current point.

  Parameters:
    `eO` - ellipse origin/centre
    `eR` - ellipse radii
  Returns:
    a unit normal vector to the tangent plane of the ellipsoid in the point.

### to3DXY

    Vec3D to3DXY()

  Creates a 3D version of this vector in the XY plane.

  Returns:
    3D vector

### to3DXZ

    Vec3D to3DXZ()

  Creates a 3D version of this vector in the XZ plane. (The 2D Y coordinate interpreted as Z)

  Returns:
    3D vector

### to3DYZ

    Vec3D to3DYZ()

  Creates a 3D version of this vector in the YZ plane. (The 2D X coordinate interpreted as Y & 2D Y as Z)

  Returns:
    3D vector

### toArray

    float[] toArray()

### toCartesian

    Vec2D toCartesian()

  Converts the vector from polar to Cartesian space. Assumes this order: x=radius, y=theta

  Returns:
    itself as Cartesian vector

### toPolar

    Vec2D toPolar()

  Converts the current vector into polar coordinates. After the conversion the x component of the vector contains the radius (magnitude) and y the rotation angle.

  Returns:
    itself as polar vector

### x

    float x()

### y

    float y()

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD