Module com.io7m.jregions.core
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

    All Methods Static Methods Concrete Methods
    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` | `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 Detail

    - #### 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) \u2192 contains(b, c) \u2192 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

    - #### 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) \u2192 couldFitInside(b, c) \u2192 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

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