Package org.hipparchus.geometry.partitioning

Class RegionFactory<S extends Space,​P extends Point<S,​P>,​H extends Hyperplane<S,​P,​H,​I>,​I extends SubHyperplane<S,​P,​H,​I>>

  • Type Parameters:
    S - Type of the space.
    P - Type of the points in space.
    H - Type of the hyperplane.
    I - Type of the sub-hyperplane.
    public class RegionFactory<S extends Space,​P extends Point<S,​P>,​H extends Hyperplane<S,​P,​H,​I>,​I extends SubHyperplane<S,​P,​H,​I>>
extends Object
    This class is a factory for Region.

    • Constructor Detail

      • RegionFactory

        public RegionFactory()
        Simple constructor.

    • Method Detail

      • buildConvex

        @SafeVarargs
public final Region<S,​P,​H,​I> buildConvex​(H... hyperplanes)
        Build a convex region from a collection of bounding hyperplanes.
        Parameters:
        hyperplanes - collection of bounding hyperplanes
        Returns:
        a new convex region, or null if the collection is empty

      • union

        public Region<S,​P,​H,​I> union​(Region<S,​P,​H,​I> region1,
                                               Region<S,​P,​H,​I> region2)
        Compute the union of two regions.
        Parameters:
        region1 - first region (will be unusable after the operation as parts of it will be reused in the new region)
        region2 - second region (will be unusable after the operation as parts of it will be reused in the new region)
        Returns:
        a new region, result of region1 union region2

      • intersection

        public Region<S,​P,​H,​I> intersection​(Region<S,​P,​H,​I> region1,
                                                      Region<S,​P,​H,​I> region2)
        Compute the intersection of two regions.
        Parameters:
        region1 - first region (will be unusable after the operation as parts of it will be reused in the new region)
        region2 - second region (will be unusable after the operation as parts of it will be reused in the new region)
        Returns:
        a new region, result of region1 intersection region2

      • xor

        public Region<S,​P,​H,​I> xor​(Region<S,​P,​H,​I> region1,
                                             Region<S,​P,​H,​I> region2)
        Compute the symmetric difference (exclusive or) of two regions.
        Parameters:
        region1 - first region (will be unusable after the operation as parts of it will be reused in the new region)
        region2 - second region (will be unusable after the operation as parts of it will be reused in the new region)
        Returns:
        a new region, result of region1 xor region2

      • difference

        public Region<S,​P,​H,​I> difference​(Region<S,​P,​H,​I> region1,
                                                    Region<S,​P,​H,​I> region2)
        Compute the difference of two regions.
        Parameters:
        region1 - first region (will be unusable after the operation as parts of it will be reused in the new region)
        region2 - second region (will be unusable after the operation as parts of it will be reused in the new region)
        Returns:
        a new region, result of region1 minus region2

      • getComplement

        public Region<S,​P,​H,​I> getComplement​(Region<S,​P,​H,​I> region)
        Get the complement of the region (exchanged interior/exterior).
        Parameters:
        region - region to complement, it will not be modified, a new region independent region will be built
        Returns:
        a new region, complement of the specified one