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
Class ImplicitVolume

    java.lang.Object
      de.grogra.vecmath.geom.VolumeBase
          de.grogra.vecmath.geom.TransformableVolume
              de.grogra.vecmath.geom.ImplicitVolume

All Implemented Interfaces:
  Volume

Direct Known Subclasses:
  Supershape

    public abstract class ImplicitVolume

extends TransformableVolume

This abstract base class represents the geometry of an implicit function. In local object coordinates, its center is the origin, and its size is infinite.

Author:
  Reinhard Hemmerling

Nested Class Summary
`protected static class` | `ImplicitVolume.Locals`

Field Summary
`protected java.lang.ThreadLocal<ImplicitVolume.Locals>` | `locals`

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

Constructor Summary
`ImplicitVolume()`

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.
`protected abstract double` | `f(double x, double y, double z)`
`protected abstract Range` | `f(Range x, Range y, Range z)`
`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

### locals

    protected final java.lang.ThreadLocal<ImplicitVolume.Locals> locals

Constructor Detail

### ImplicitVolume

    public ImplicitVolume()

Method Detail

### boxContainsBoundary

    public boolean boxContainsBoundary(BoundingBox box,
                                       Tuple3d center,
                                       double radius,
                                       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

### f

    protected abstract double f(double x,
                                double y,
                                double z)

### f

    protected abstract Range f(Range x,
                               Range y,
                               Range z)

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

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