com.io7m.jregions.core.parameterized.volumes

## Class PVolumesBD

- java.lang.Object
- - com.io7m.jregions.core.parameterized.volumes.PVolumesBD

-     public final class PVolumesBD
      extends Object

  Functions over volumes.

  These functions operate using the concepts of minimum-x, maximum-x, minimum-y, maximum-y, minimum-z, maximum-z, edges. It is up to individual applications to assign meaning to these edges such as "left" for minimum-x, "top" for minimum-y, or "far" for minimum-z.

- - ### Method Summary

    All Methods Static Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `static <S,T> PVolumeBD<T>` | `cast(PVolumeBD<S> volume)` Brand a given volume as belonging to a different coordinate space.
    `static <S> PVolumeBD<S>` | `containing(PVolumeBD<S> a, PVolumeBD<S> b)` Construct a volume that will contain both `a` and `b`.
    `static <S> boolean` | `contains(PVolumeBD<S> a, PVolumeBD<S> b)` Determine whether or not one volume contains another.
    `static <S> boolean` | `containsPoint(PVolumeBD<S> a, BigDecimal x, BigDecimal y, BigDecimal z)` Determine whether or not a volume contains a given point.
    `static <S> boolean` | `couldFitInside(PVolumeBD<S> a, PVolumeBD<S> b)` Determine whether or not one volume could fit inside another.
    `static <S> PVolumeBD<S>` | `create(BigDecimal x, BigDecimal y, BigDecimal z, BigDecimal size_x, BigDecimal size_y, BigDecimal size_z)` Create a volume of size (`size_x`, `size_y`, `size_z`) placing the minimum corner at `(x, y, z)`.
    `static <S> PVolumeBD<S>` | `moveAbsolute(PVolumeBD<S> volume, BigDecimal x, BigDecimal y, BigDecimal z)` Move the given volume to `(x, y, z)`.
    `static <S> PVolumeBD<S>` | `moveRelative(PVolumeBD<S> volume, BigDecimal x, BigDecimal y, BigDecimal z)` Move the given volume by `(x, y, z)`.
    `static <S> PVolumeBD<S>` | `moveToOrigin(PVolumeBD<S> volume)` Move the given volume to `(0, 0, 0)`.
    `static <S> boolean` | `overlaps(PVolumeBD<S> a, PVolumeBD<S> b)` Determine whether or not two volumes overlap.
    `static <S> String` | `show(PVolumeBD<S> volume)`
    `static <S> String` | `showToBuilder(PVolumeBD<S> volume, StringBuilder sb)`
    `static <S> PVolumeSizeBD<S>` | `size(PVolumeBD<S> volume)`
    `static <S> PVolumeXYZSplitBD<S,PVolumeBD<S>>` | `splitAtXYZ(PVolumeBD<S> v, BigDecimal x, BigDecimal y, BigDecimal z)` Split the given volume at point `(x, y, z)`.

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

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

- - ### Method Detail

    - #### create

          public static <S> PVolumeBD<S> create(BigDecimal x,
                                                BigDecimal y,
                                                BigDecimal z,
                                                BigDecimal size_x,
                                                BigDecimal size_y,
                                                BigDecimal size_z)

      Create a volume of size (`size_x`, `size_y`, `size_z`) placing the minimum corner at `(x, y, z)`.
      Type Parameters:
        `S` - The coordinate space of the volume
      Parameters:
        `x` - The X value of the minimum corner
        `y` - The Y value of the minimum corner
        `z` - The Z value of the minimum corner
        `size_x` - The size of the volume on the X axis
        `size_y` - The size of the volume on the Y axis
        `size_z` - The size of the volume on the Z axis
      Returns:
        A volume

    - #### contains

          public static <S> boolean contains(PVolumeBD<S> a,
                                             PVolumeBD<S> b)

      Determine whether or not one volume contains another.

      Containing is reflexive: `contains(a, a) == true`.

      Containing is transitive: `contains(a, b) → contains(b, c) → contains(a, c)`.

      Containing is not necessarily symmetric.

      Type Parameters:
        `S` - The coordinate space of the volumes
      Parameters:
        `a` - Volume A
        `b` - Volume B
      Returns:
        `true` iff `a` contains `b`

    - #### moveRelative

          public static <S> PVolumeBD<S> moveRelative(PVolumeBD<S> volume,
                                                      BigDecimal x,
                                                      BigDecimal y,
                                                      BigDecimal z)

      Move the given volume by `(x, y, z)`.
      Type Parameters:
        `S` - The coordinate space of the volume
      Parameters:
        `volume` - The volume
        `x` - The amount to move on the X axis
        `y` - The amount to move on the Y axis
        `z` - The amount to move on the Z axis
      Returns:
        A moved volume

    - #### moveAbsolute

          public static <S> PVolumeBD<S> moveAbsolute(PVolumeBD<S> volume,
                                                      BigDecimal x,
                                                      BigDecimal y,
                                                      BigDecimal z)

      Move the given volume to `(x, y, z)`.
      Type Parameters:
        `S` - The coordinate space of the volume
      Parameters:
        `volume` - The volume
        `x` - The position to which to move on the X axis
        `y` - The position to which to move on the Y axis
        `z` - The position to which to move on the Z axis
      Returns:
        A moved volume

    - #### moveToOrigin

          public static <S> PVolumeBD<S> moveToOrigin(PVolumeBD<S> volume)

      Move the given volume to `(0, 0, 0)`.
      Type Parameters:
        `S` - The coordinate space of the volume
      Parameters:
        `volume` - The volume
      Returns:
        A moved volume

    - #### cast

          public static <S,T> PVolumeBD<T> cast(PVolumeBD<S> volume)

      Brand a given volume as belonging to a different coordinate space. Mixing up coordinate spaces is a common source of difficult-to-locate bugs. Use at your own risk.
      Type Parameters:
        `S` - The starting coordinate space
        `T` - The resulting coordinate space
      Parameters:
        `volume` - A volume
      Returns:
        `volume`

    - #### overlaps

          public static <S> boolean overlaps(PVolumeBD<S> a,
                                             PVolumeBD<S> b)

      Determine whether or not two volumes overlap.

      Overlapping is reflexive: `overlaps(a, a) == true`.

      Overlapping is symmetric: `overlaps(a, b) == overlaps(b, a)`.

      Overlapping is not necessarily transitive.

      Type Parameters:
        `S` - The coordinate space of the volumes
      Parameters:
        `a` - A volume
        `b` - A volume
      Returns:
        `true` iff `a` overlaps `b`

    - #### couldFitInside

          public static <S> boolean couldFitInside(PVolumeBD<S> a,
                                                   PVolumeBD<S> b)

      Determine whether or not one volume could fit inside another.

      Fitting is reflexive: `couldFitInside(a, a) == true`.

      Fitting is transitive: `couldFitInside(a, b) → couldFitInside(b, c) → couldFitInside(a, c)`.

      Fitting is not necessarily symmetric.

      Type Parameters:
        `S` - The coordinate space of the volumes
      Parameters:
        `a` - A volume
        `b` - A volume
      Returns:
        `true` iff `a` could fit inside `b`

    - #### containing

          public static <S> PVolumeBD<S> containing(PVolumeBD<S> a,
                                                    PVolumeBD<S> b)

      Construct a volume that will contain both `a` and `b`.
      Type Parameters:
        `S` - The coordinate space of the volumes
      Parameters:
        `a` - A volume
        `b` - A volume
      Returns:
        A volume containing `a` and `b`

    - #### containsPoint

          public static <S> boolean containsPoint(PVolumeBD<S> a,
                                                  BigDecimal x,
                                                  BigDecimal y,
                                                  BigDecimal z)

      Determine whether or not a volume contains a given point.

      Type Parameters:
        `S` - The coordinate space of the volume
      Parameters:
        `a` - A volume
        `x` - The X coordinate of the point
        `y` - The Y coordinate of the point
        `z` - The Z coordinate of the point
      Returns:
        `true` iff `a` contains `(x, y, z)`

    - #### splitAtXYZ

          public static <S> PVolumeXYZSplitBD<S,PVolumeBD<S>> splitAtXYZ(PVolumeBD<S> v,
                                                                         BigDecimal x,
                                                                         BigDecimal y,
                                                                         BigDecimal z)

      Split the given volume at point `(x, y, z)`.

      Type Parameters:
        `S` - The coordinate space of the volume
      Parameters:
        `v` - A volume
        `x` - The X coordinate of the point
        `y` - The Y coordinate of the point
        `z` - The Z coordinate of the point
      Returns:
        `true` iff `a` contains `(x, y, z)`

    - #### show

          public static <S> String show(PVolumeBD<S> volume)

      Type Parameters:
        `S` - The coordinate space of the volume
      Parameters:
        `volume` - The volume
      Returns:
        A terse string describing the position and size of the volume

    - #### size

          public static <S> PVolumeSizeBD<S> size(PVolumeBD<S> volume)

      Type Parameters:
        `S` - The coordinate space of the volume
      Parameters:
        `volume` - The volume
      Returns:
        The size of the volume

    - #### showToBuilder

          public static <S> String showToBuilder(PVolumeBD<S> volume,
                                                 StringBuilder sb)

      Type Parameters:
        `S` - The coordinate space of the volume
      Parameters:
        `volume` - The volume
        `sb` - A string builder
      Returns:
        A terse string describing the position and size of the volume

Copyright © 2017 <code@io7m.com> http://io7m.com