Overview | Package | Class | Tree | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## de.grogra.vecmath.geom
Interface Volume

All Known Implementing Classes:
  BoundingBox, CompoundVolume, Cone, CSGComplement, CSGDifference, CSGIntersection, CSGUnion, Cube, Cylinder, EmptyVolume, Frustum, FrustumBase, HalfSpace, ImplicitVolume, MeshVolume, MyMeshVolume, OctreeUnion, SensorDisc, SimpleUnion, SkySphere, Sphere, Square, Supershape, TransformableVolume, UnionBase, VolumeBase

    public interface Volume

This interface represents three dimensional geometric objects having a volume.

Author:
  Ole Kniemeyer

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 `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 `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 `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`.
`int` | `getId()` Returns the id which has been set by `setId(int)`.
`Volume` | `operator$and(Volume v)` This operator method creates the intersection of this volume and `v`.
`Volume` | `operator$com()` This operator method creates the complement of this volume.
`Volume` | `operator$or(Volume v)` This operator method creates the union of this volume and `v`.
`Volume` | `operator$sub(Volume v)` This operator method creates the difference between `a` and `b`.
`void` | `setId(int id)` Sets a unique identifier for this volume.

Method Detail

### boxContainsBoundary

    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. 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

    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`. 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

    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 `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

    void computeTangents(Intersection is,
                         Vector3d dpdu,
                         Vector3d dpdv)

  This method computes the derivatives of the surface point (as function of the uv-coordinates, see `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

    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 `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

    boolean contains(Tuple3d point,
                     boolean open)

  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

    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`.

  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

### getId

    int getId()

  Returns the id which has been set by `setId(int)`. Identifiers are non-negative and should be consecutive starting at zero, so that they can be used as indices into arrays which associate additional information with the volumes. Small gaps in the set of used identifiers are tolerable.

  Returns:
    id of this volume

### operator$and

    Volume operator$and(Volume v)

  This operator method creates the intersection of this volume and `v`.

  Parameters:
    `v` - a volume
  Returns:
    the intersection of `a` and `b`
  See Also:
    `CSGIntersection`

### operator$com

    Volume operator$com()

  This operator method creates the complement of this volume.

  Returns:
    the complement of this volume
  See Also:
    `CSGComplement`

### operator$or

    Volume operator$or(Volume v)

  This operator method creates the union of this volume and `v`.

  Parameters:
    `v` - a volume
  Returns:
    the union of this volume and `v`
  See Also:
    `CSGUnion`

### operator$sub

    Volume operator$sub(Volume v)

  This operator method creates the difference between `a` and `b`.

  Parameters:
    `v` - the volume to be subtracted
  Returns:
    the difference between this volume and `b`
  See Also:
    `CSGDifference`

### setId

    void setId(int id)

  Sets a unique identifier for this volume. `id` has to be non-negative, the `id`s of all coexisting volumes should be consecutive numbers starting at zero.

  Parameters:
    `id` - id for this volume
  See Also:
    `getId()`

Overview | Package | Class | Tree | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD