org.apache.commons.math3.geometry.euclidean.twod

## Class Line.LineTransform

- java.lang.Object
- - org.apache.commons.math3.geometry.euclidean.twod.Line.LineTransform

All Implemented Interfaces:
  Transform<Euclidean2D,Euclidean1D>

Enclosing class:
  Line

    private static class Line.LineTransform
    extends Object
    implements Transform<Euclidean2D,Euclidean1D>

Class embedding an affine transform.

This class is used in order to apply an affine transform to a line. Using a specific object allow to perform some computations on the transform only once even if the same transform is to be applied to a large number of lines (for example to a large polygon)./

### Field Summary

Fields
`private double` `c11`
`private double` `c1X`
`private double` `c1Y`
`private double` `cX1`
`private double` `cXX`
`private double` `cXY`
`private double` `cY1`
`private double` `cYX`
`private double` `cYY`

### Constructor Summary

Constructors
Constructor and Description
`Line.LineTransform(AffineTransform transform)` Build an affine line transform from a n `AffineTransform`.

### Method Summary

Methods
`Line` `apply(Hyperplane<Euclidean2D> hyperplane)` Transform an hyperplane of a space.
`SubHyperplane<Euclidean1D>` `apply(SubHyperplane<Euclidean1D> sub, Hyperplane<Euclidean2D> original, Hyperplane<Euclidean2D> transformed)` Transform a sub-hyperplane embedded in an hyperplane.
`Vector2D` `apply(Vector<Euclidean2D> point)` Transform a point of a space.

### Methods inherited from class java.lang.Object

`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

### Field Detail

#### cXX

    private double cXX

#### cXY

    private double cXY

#### cX1

    private double cX1

#### cYX

    private double cYX

#### cYY

    private double cYY

#### cY1

    private double cY1

#### c1Y

    private double c1Y

#### c1X

    private double c1X

#### c11

    private double c11

### Constructor Detail

#### Line.LineTransform

    public Line.LineTransform(AffineTransform transform)
                       throws MathIllegalArgumentException

Build an affine line transform from a n `AffineTransform`.

Parameters:
  `transform` - transform to use (must be invertible otherwise the `apply(Hyperplane)` method would work only for some lines, and fail for other ones)
Throws:
  `MathIllegalArgumentException` - if the transform is non invertible

### Method Detail

#### apply

    public Vector2D apply(Vector<Euclidean2D> point)

Transform a point of a space.

Specified by:
  `apply` in interface `Transform<Euclidean2D,Euclidean1D>`
Parameters:
  `point` - point to transform
Returns:
  a new object representing the transformed point

#### apply

    public Line apply(Hyperplane<Euclidean2D> hyperplane)

Transform an hyperplane of a space.

Specified by:
  `apply` in interface `Transform<Euclidean2D,Euclidean1D>`
Parameters:
  `hyperplane` - hyperplane to transform
Returns:
  a new object representing the transformed hyperplane

#### apply

    public SubHyperplane<Euclidean1D> apply(SubHyperplane<Euclidean1D> sub,
                                   Hyperplane<Euclidean2D> original,
                                   Hyperplane<Euclidean2D> transformed)

Transform a sub-hyperplane embedded in an hyperplane.

Specified by:
  `apply` in interface `Transform<Euclidean2D,Euclidean1D>`
Parameters:
  `sub` - sub-hyperplane to transform
  `original` - hyperplane in which the sub-hyperplane is defined (this is the original hyperplane, the transform has not been applied to it)
  `transformed` - hyperplane in which the sub-hyperplane is defined (this is the transformed hyperplane, the transform has been applied to it)
Returns:
  a new object representing the transformed sub-hyperplane