org.apache.commons.math3.geometry.partitioning

## Class AbstractSubHyperplane<S extends Space,T extends Space>

- java.lang.Object
- - org.apache.commons.math3.geometry.partitioning.AbstractSubHyperplane<S,T>

Type Parameters:
  `S` - Type of the embedding space.
  `T` - Type of the embedded sub-space.

All Implemented Interfaces:
  SubHyperplane<S>

Direct Known Subclasses:
  SubLine, SubOrientedPoint, SubPlane

    public abstract class AbstractSubHyperplane<S extends Space,T extends Space>
    extends java.lang.Object
    implements SubHyperplane<S>

This class implements the dimension-independent parts of `SubHyperplane`.

sub-hyperplanes are obtained when parts of an `hyperplane` are chopped off by other hyperplanes that intersect it. The remaining part is a convex region. Such objects appear in `BSP trees` as the intersection of a cut hyperplane with the convex region which it splits, the chopping hyperplanes are the cut hyperplanes closer to the tree root.

Since:
  3.0
Version:
  $Id: AbstractSubHyperplane.java 1421448 2012-12-13 19:45:57Z tn $

### Nested Class Summary

### Nested classes/interfaces inherited from interface org.apache.commons.math3.geometry.partitioning.SubHyperplane

`SubHyperplane.SplitSubHyperplane<U extends Space>`

### Field Summary

Fields
`private Hyperplane<S>` `hyperplane` Underlying hyperplane.
`private Region<T>` `remainingRegion` Remaining region of the hyperplane.

### Constructor Summary

Constructors
`protected` `AbstractSubHyperplane(Hyperplane<S> hyperplane, Region<T> remainingRegion)` Build a sub-hyperplane from an hyperplane and a region.

### Method Summary

Methods
`AbstractSubHyperplane<S,T>` `applyTransform(Transform<S,T> transform)` Apply a transform to the instance.
`protected abstract AbstractSubHyperplane<S,T>` `buildNew(Hyperplane<S> hyper, Region<T> remaining)` Build a sub-hyperplane from an hyperplane and a region.
`AbstractSubHyperplane<S,T>` `copySelf()` Copy the instance.
`Hyperplane<S>` `getHyperplane()` Get the underlying hyperplane.
`Region<T>` `getRemainingRegion()` Get the remaining region of the hyperplane.
`double` `getSize()` Get the size of the instance.
`boolean` `isEmpty()` Check if the instance is empty.
`private BSPTree<T>` `recurseTransform(BSPTree<T> node, Hyperplane<S> transformed, Transform<S,T> transform)` Recursively transform a BSP-tree from a sub-hyperplane.
`AbstractSubHyperplane<S,T>` `reunite(SubHyperplane<S> other)` Compute the union of the instance and another sub-hyperplane.
`abstract Side` `side(Hyperplane<S> hyper)` Compute the relative position of the instance with respect to an hyperplane.
`abstract SubHyperplane.SplitSubHyperplane<S>` `split(Hyperplane<S> hyper)` Split the instance in two parts by an hyperplane.

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

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

### Field Detail

#### hyperplane

    private final Hyperplane<S extends Space> hyperplane

Underlying hyperplane.

#### remainingRegion

    private final Region<T extends Space> remainingRegion

Remaining region of the hyperplane.

### Constructor Detail

#### AbstractSubHyperplane

    protected AbstractSubHyperplane(Hyperplane<S> hyperplane,
                         Region<T> remainingRegion)

Build a sub-hyperplane from an hyperplane and a region.

Parameters:
  `hyperplane` - underlying hyperplane
  `remainingRegion` - remaining region of the hyperplane

### Method Detail

#### buildNew

    protected abstract AbstractSubHyperplane<S,T> buildNew(Hyperplane<S> hyper,
                                      Region<T> remaining)

Build a sub-hyperplane from an hyperplane and a region.

Parameters:
  `hyper` - underlying hyperplane
  `remaining` - remaining region of the hyperplane
Returns:
  a new sub-hyperplane

#### copySelf

    public AbstractSubHyperplane<S,T> copySelf()

Copy the instance.

The instance created is completely independent of the original one. A deep copy is used, none of the underlying objects are shared (except for the nodes attributes and immutable objects).

Specified by:
  `copySelf` in interface `SubHyperplane<S extends Space>`
Returns:
  a new sub-hyperplane, copy of the instance

#### getHyperplane

    public Hyperplane<S> getHyperplane()

Get the underlying hyperplane.

Specified by:
  `getHyperplane` in interface `SubHyperplane<S extends Space>`
Returns:
  underlying hyperplane

#### getRemainingRegion

    public Region<T> getRemainingRegion()

Get the remaining region of the hyperplane.

The returned region is expressed in the canonical hyperplane frame and has the hyperplane dimension. For example a chopped hyperplane in the 3D euclidean is a 2D plane and the corresponding region is a convex 2D polygon.

Returns:
  remaining region of the hyperplane

#### getSize

    public double getSize()

Get the size of the instance.

Specified by:
  `getSize` in interface `SubHyperplane<S extends Space>`
Returns:
  the size of the instance (this is a length in 1D, an area in 2D, a volume in 3D ...)

#### reunite

    public AbstractSubHyperplane<S,T> reunite(SubHyperplane<S> other)

Compute the union of the instance and another sub-hyperplane.

Specified by:
  `reunite` in interface `SubHyperplane<S extends Space>`
Parameters:
  `other` - other sub-hyperplane to union (must be in the same hyperplane as the instance)
Returns:
  a new sub-hyperplane, union of the instance and other

#### applyTransform

    public AbstractSubHyperplane<S,T> applyTransform(Transform<S,T> transform)

Apply a transform to the instance.

The instance must be a (D-1)-dimension sub-hyperplane with respect to the transform not a (D-2)-dimension sub-hyperplane the transform knows how to transform by itself. The transform will consist in transforming first the hyperplane and then the all region using the various methods provided by the transform.

Parameters:
  `transform` - D-dimension transform to apply
Returns:
  the transformed instance

#### recurseTransform

    private BSPTree<T> recurseTransform(BSPTree<T> node,
                              Hyperplane<S> transformed,
                              Transform<S,T> transform)

Recursively transform a BSP-tree from a sub-hyperplane.

Parameters:
  `node` - current BSP tree node
  `transformed` - image of the instance hyperplane by the transform
  `transform` - transform to apply
Returns:
  a new tree

#### side

    public abstract Side side(Hyperplane<S> hyper)

Compute the relative position of the instance with respect to an hyperplane.

Specified by:
  `side` in interface `SubHyperplane<S extends Space>`
Parameters:
  `hyper` - hyperplane to check instance against
Returns:
  one of `Side.PLUS`, `Side.MINUS`, `Side.BOTH`, `Side.HYPER`

#### split

    public abstract SubHyperplane.SplitSubHyperplane<S> split(Hyperplane<S> hyper)

Split the instance in two parts by an hyperplane.

Specified by:
  `split` in interface `SubHyperplane<S extends Space>`
Parameters:
  `hyper` - splitting hyperplane
Returns:
  an object containing both the part of the instance on the plus side of the instance and the part of the instance on the minus side of the instance

#### isEmpty

    public boolean isEmpty()

Check if the instance is empty.

Specified by:
  `isEmpty` in interface `SubHyperplane<S extends Space>`
Returns:
  true if the instance is empty