## de.grogra.vecmath.geom Class Cube

```java.lang.Object
de.grogra.vecmath.geom.VolumeBase
de.grogra.vecmath.geom.TransformableVolume
de.grogra.vecmath.geom.Cube
```
All Implemented Interfaces:
Volume

`public class Cubeextends TransformableVolume`

This class represents the geometry of a cube. In local object coordinates, it is axis-aligned with coordinates between (-1, -1, -1) and (1, 1, 1).

Author:
Ole Kniemeyer

Field Summary
`static int` `BACK`
Face index indicating the back face (direction +y)
`static int` `BOTTOM`
Face index indicating the bottom face (direction -z)
`static int` `FRONT`
Face index indicating the front face (direction -y)
`static int` `LEFT`
Face index indicating the left face (direction -x)
`static int` `RIGHT`
Face index indicating the right face (direction +x)
`static int` `TOP`
Face index indicating the top face (direction +z)

Fields inherited from class de.grogra.vecmath.geom.TransformableVolume
`m00, m01, m02, m10, m11, m12, m20, m21, m22, t0, t1, t2`

Constructor Summary
`Cube()`

Method Summary
` boolean` ```boxContainsBoundary(BoundingBox box, Tuple3d center, double radius, Variables temp)```
Returns `true` if the specified `box` contains (part of) the boundary surface of this volume.
` boolean` ```computeIntersections(Line line, int which, IntersectionList list, Intersection excludeStart, Intersection excludeEnd)```
Computes intersections between the boundary surface of this object and the specified `line`.
` void` ```computeNormal(Intersection is, Vector3d normal)```
This method computes the unit normal vector of an intersection `is` which has been computed previously by the invocation of `Volume.computeIntersections(de.grogra.vecmath.geom.Line, int, de.grogra.vecmath.geom.IntersectionList, de.grogra.vecmath.geom.Intersection, de.grogra.vecmath.geom.Intersection)` on this volume.
` void` ```computeTangents(Intersection is, Vector3d dpdu, Vector3d dpdv)```
This method computes the derivatives of the surface point (as function of the uv-coordinates, see `Volume.computeUV(de.grogra.vecmath.geom.Intersection, javax.vecmath.Vector2d)`) with respect to u and v at the intersection point.
` void` ```computeUV(Intersection is, Vector2d uv)```
This method computes the uv-coordinates of an intersection point `is` which has been computed previously by the invocation of `Volume.computeIntersections(de.grogra.vecmath.geom.Line, int, de.grogra.vecmath.geom.IntersectionList, de.grogra.vecmath.geom.Intersection, de.grogra.vecmath.geom.Intersection)` on this volume.
` boolean` ```contains(Tuple3d point, boolean open)```
Determines if the given `point` lies within this object.
` void` ```getExtent(Tuple3d min, Tuple3d max, Variables temp)```
Computes the extent of this volume, i.e., an axis-aligned bounding box between `min` and `max`.

Methods inherited from class de.grogra.vecmath.geom.TransformableVolume
`getDiscExtent, getDiscsExtent, getFrobeniusNorm, getObjectToWorldRotationScale, getTransformation, invalidate, invTransformPoint, scale, setTransformation, setTransformation, transformPoint, transformTranspose, transformVector, translate`

Methods inherited from class de.grogra.vecmath.geom.VolumeBase
`addConvexIntersections, getId, operator\$and, operator\$com, operator\$or, operator\$sub, setId`

Methods inherited from class java.lang.Object
`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

Field Detail

### BACK

`public static final int BACK`
Face index indicating the back face (direction +y)

Constant Field Values

### BOTTOM

`public static final int BOTTOM`
Face index indicating the bottom face (direction -z)

Constant Field Values

### FRONT

`public static final int FRONT`
Face index indicating the front face (direction -y)

Constant Field Values

### LEFT

`public static final int LEFT`
Face index indicating the left face (direction -x)

Constant Field Values

### RIGHT

`public static final int RIGHT`
Face index indicating the right face (direction +x)

Constant Field Values

### TOP

`public static final int TOP`
Face index indicating the top face (direction +z)

Constant Field Values
Constructor Detail

### Cube

`public Cube()`
Method Detail

### boxContainsBoundary

```public boolean boxContainsBoundary(BoundingBox box,
Tuple3d center,
Variables temp)```
Description copied from interface: `Volume`
Returns `true` if the specified `box` contains (part of) the boundary surface of this volume. Otherwise, if box and boundary do not overlap, this method should return `false`, but may also return `true` if an exact computation would be too expensive or complicated.

Note that a box contains the boundary of a closed set S iff both have a non-empty intersection and the box is not contained in the open set of S.

Parameters:
`box` - bounding box
`center` - center coordinates of box
`radius` - radius of enclosing sphere
`temp` - has to be provided by the invoker, may be used in implementations
Returns:
`true` if box contains (part of) the boundary of this volume

### computeIntersections

```public boolean computeIntersections(Line line,
int which,
IntersectionList list,
Intersection excludeStart,
Intersection excludeEnd)```
Description copied from interface: `Volume`
Computes intersections between the boundary surface of this object and the specified `line`. The intersections are added to `list` in ascending order of distance (i.e., of `Intersection.parameter`), where the `parameter` has to lie between `line.start` and `line.end`. Implementations of this method must not clear or modify the existing intersections in `list`.

The parameter `which` has to be one of `Intersection.ALL`, `Intersection.CLOSEST`, `Intersection.ANY`. It determines if all intersections have to be added to the list, only the closest (minimal value of `Intersection.parameter`), or an arbitrary of the set of all intersections. Only in case of `ALL`, the return value of this method is precise.

If specific intersection points should be excluded from the list of computed intersections, they have to be specified in `excludeStart` and `excludeEnd`. The intersection point of `excludeStart` has to be the starting point of `line`, the intersection point of `excludeEnd` has to be the end point of `line`. The exclusion of intersections is a useful feature for ray-tracing, e.g., when a ray is re-emitted at an intersection point in another direction.

Parameters:
`line` - a line
`which` - one of `Intersection.ALL`, `Intersection.CLOSEST`, `Intersection.ANY`, this determines which intersections have to be added to `list`
`list` - the intersections are added to this list
`excludeStart` - intersection at start point which shall be excluded, or `null`
`excludeEnd` - intersection at end point which shall be excluded, or `null`
Returns:
`true` iff the beginning of the line lies within the volume (i.e., if the line starts within the volume or enters the volume at the starting point); however note that the returned value is valid only if `which == Intersection.ALL`

### computeNormal

```public void computeNormal(Intersection is,
Vector3d normal)```
Description copied from interface: `Volume`
This method computes the unit normal vector of an intersection `is` which has been computed previously by the invocation of `Volume.computeIntersections(de.grogra.vecmath.geom.Line, int, de.grogra.vecmath.geom.IntersectionList, de.grogra.vecmath.geom.Intersection, de.grogra.vecmath.geom.Intersection)` on this volume.

Parameters:
`is` - a previously computed intersection
`normal` - resulting unit vector is placed in here

### computeTangents

```public void computeTangents(Intersection is,
Vector3d dpdu,
Vector3d dpdv)```
Description copied from interface: `Volume`
This method computes the derivatives of the surface point (as function of the uv-coordinates, see `Volume.computeUV(de.grogra.vecmath.geom.Intersection, javax.vecmath.Vector2d)`) with respect to u and v at the intersection point.

Parameters:
`is` - a previously computed intersection
`dpdu` - resulting derivative with respect to u
`dpdv` - resulting derivative with respect to v

### computeUV

```public void computeUV(Intersection is,
Vector2d uv)```
Description copied from interface: `Volume`
This method computes the uv-coordinates of an intersection point `is` which has been computed previously by the invocation of `Volume.computeIntersections(de.grogra.vecmath.geom.Line, int, de.grogra.vecmath.geom.IntersectionList, de.grogra.vecmath.geom.Intersection, de.grogra.vecmath.geom.Intersection)` on this volume.

Parameters:
`is` - a previously computed intersection
`uv` - resulting uv-coordinates are placed in here

### contains

```public boolean contains(Tuple3d point,
boolean open)```
Description copied from interface: `Volume`
Determines if the given `point` lies within this object. If `open` is `true`, the interior of the volume is considered (the largest open set contained in the volume, i.e., excluding the boundary), otherwise the closure of the volume.

Parameters:
`point` - a point in global world coordinates
`open` - consider open or closed set
Returns:
`true` iff `point` is an element of the set

### getExtent

```public void getExtent(Tuple3d min,
Tuple3d max,
Variables temp)```
Description copied from interface: `Volume`
Computes the extent of this volume, i.e., an axis-aligned bounding box between `min` and `max`.

Parameters:
`min` - minimum coordinates of bounding box are placed in here
`max` - maximum coordinates of bounding box are placed in here
`temp` - has to be provided by the invoker, may be used in implementations