Package com.io7m.jregions.core.unparameterized.volumes

# Class VolumesD

java.lang.Object
com.io7m.jregions.core.unparameterized.volumes.VolumesD

    public final class VolumesD
    extends java.lang.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

  Modifier and Type | Method | Description
  --- | --- | ---
  `static VolumeD` | `containing​(VolumeD a, VolumeD b)` | Construct a volume that will contain both `a` and `b`.
  `static boolean` | `contains​(VolumeD a, VolumeD b)` | Determine whether or not one volume contains another.
  `static boolean` | `containsPoint​(VolumeD a, double x, double y, double z)` | Determine whether or not a volume contains a given point.
  `static boolean` | `couldFitInside​(VolumeD a, VolumeD b)` | Determine whether or not one volume could fit inside another.
  `static VolumeD` | `create​(double x, double y, double z, double size_x, double size_y, double size_z)` | Create a volume of size (`size_x`, `size_y`, `size_z`) placing the minimum corner at `(x, y, z)`.
  `static VolumeD` | `moveAbsolute​(VolumeD volume, double x, double y, double z)` | Move the given volume to `(x, y, z)`.
  `static VolumeD` | `moveRelative​(VolumeD volume, double x, double y, double z)` | Move the given volume by `(x, y, z)`.
  `static VolumeD` | `moveRelativeClamped​(VolumeD container, VolumeD volume, double x, double y, double z)` | Move the given volume by `(x, y, z)`, without allowing `volume` to leave `container`.
  `static VolumeD` | `moveRelativeClampedX​(VolumeD container, VolumeD volume, double x)` | Move the given volume by `x`, without allowing `volume` to leave `container`.
  `static VolumeD` | `moveRelativeClampedY​(VolumeD container, VolumeD volume, double y)` | Move the given volume by `y`, without allowing `volume` to leave `container`.
  `static VolumeD` | `moveRelativeClampedZ​(VolumeD container, VolumeD volume, double z)` | Move the given volume by `z`, without allowing `volume` to leave `container`.
  `static VolumeD` | `moveToOrigin​(VolumeD volume)` | Move the given volume to `(0, 0, 0)`.
  `static boolean` | `overlaps​(VolumeD a, VolumeD b)` | Determine whether or not two volumes overlap.
  `static java.lang.String` | `show​(VolumeD volume)` |
  `static java.lang.String` | `showToBuilder​(VolumeD volume, java.lang.StringBuilder sb)` |
  `static VolumeSizeD` | `size​(VolumeD volume)` |
  `static VolumeXYZSplitD<VolumeD>` | `splitAtXYZ​(VolumeD v, double x, double y, double 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 Details

  - ### create

    public static VolumeD create​(double x, double y, double z, double size_x, double size_y, double size_z)
    Create a volume of size (`size_x`, `size_y`, `size_z`) placing the minimum corner at `(x, y, z)`.
    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 boolean contains​(VolumeD a, VolumeD 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.

    Parameters:
      `a` - Volume A
      `b` - Volume B
    Returns:
      `true` iff `a` contains `b`

  - ### moveRelative

    public static VolumeD moveRelative​(VolumeD volume, double x, double y, double z)
    Move the given volume by `(x, y, z)`.
    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

  - ### moveRelativeClampedX

    public static VolumeD moveRelativeClampedX​(VolumeD container, VolumeD volume, double x)
    Move the given volume by `x`, without allowing `volume` to leave `container`.
    Parameters:
      `container` - The container volume
      `volume` - The volume
      `x` - The amount to move on the X axis
    Returns:
      A moved volume
    Since:
      3.0.0

  - ### moveRelativeClampedY

    public static VolumeD moveRelativeClampedY​(VolumeD container, VolumeD volume, double y)
    Move the given volume by `y`, without allowing `volume` to leave `container`.
    Parameters:
      `container` - The container volume
      `volume` - The volume
      `y` - The amount to move on the Y axis
    Returns:
      A moved volume
    Since:
      3.0.0

  - ### moveRelativeClampedZ

    public static VolumeD moveRelativeClampedZ​(VolumeD container, VolumeD volume, double z)
    Move the given volume by `z`, without allowing `volume` to leave `container`.
    Parameters:
      `container` - The container volume
      `volume` - The volume
      `z` - The amount to move on the Z axis
    Returns:
      A moved volume
    Since:
      3.0.0

  - ### moveRelativeClamped

    public static VolumeD moveRelativeClamped​(VolumeD container, VolumeD volume, double x, double y, double z)
    Move the given volume by `(x, y, z)`, without allowing `volume` to leave `container`.
    Parameters:
      `container` - The container volume
      `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
    Since:
      3.0.0

  - ### moveAbsolute

    public static VolumeD moveAbsolute​(VolumeD volume, double x, double y, double z)
    Move the given volume to `(x, y, z)`.
    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 VolumeD moveToOrigin​(VolumeD volume)
    Move the given volume to `(0, 0, 0)`.
    Parameters:
      `volume` - The volume
    Returns:
      A moved volume

  - ### overlaps

    public static boolean overlaps​(VolumeD a, VolumeD 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.

    Parameters:
      `a` - A volume
      `b` - A volume
    Returns:
      `true` iff `a` overlaps `b`

  - ### couldFitInside

    public static boolean couldFitInside​(VolumeD a, VolumeD 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.

    Parameters:
      `a` - A volume
      `b` - A volume
    Returns:
      `true` iff `a` could fit inside `b`

  - ### containing

    public static VolumeD containing​(VolumeD a, VolumeD b)
    Construct a volume that will contain both `a` and `b`.
    Parameters:
      `a` - A volume
      `b` - A volume
    Returns:
      A volume containing `a` and `b`

  - ### containsPoint

    public static boolean containsPoint​(VolumeD a, double x, double y, double z)

    Determine whether or not a volume contains a given point.

    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 VolumeXYZSplitD<VolumeD> splitAtXYZ​(VolumeD v, double x, double y, double z)

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

    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 java.lang.String show​(VolumeD volume)
    Parameters:
      `volume` - The volume
    Returns:
      A terse string describing the position and size of the volume

  - ### size

    public static VolumeSizeD size​(VolumeD volume)
    Parameters:
      `volume` - The volume
    Returns:
      The size of the volume

  - ### showToBuilder

    public static java.lang.String showToBuilder​(VolumeD volume, java.lang.StringBuilder sb)
    Parameters:
      `volume` - The volume
      `sb` - A string builder
    Returns:
      A terse string describing the position and size of the volume