/*

* Copyright 1996-2008 Sun Microsystems, Inc. All Rights Reserved.

* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

*

* This code is free software; you can redistribute it and/or modify it

* under the terms of the GNU General Public License version 2 only, as

* published by the Free Software Foundation. Sun designates this

* particular file as subject to the "Classpath" exception as provided

* by Sun in the LICENSE file that accompanied this code.

*

* This code is distributed in the hope that it will be useful, but WITHOUT

* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License

* version 2 for more details (a copy is included in the LICENSE file that

* accompanied this code).

*

* You should have received a copy of the GNU General Public License version

* 2 along with this work; if not, write to the Free Software Foundation,

* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

*

* Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,

* CA 95054 USA or visit www.sun.com if you need additional information or

* have any questions.

*

*/

package org.scijava.java3d;

import org.scijava.vecmath.Point3d;

import org.scijava.vecmath.Point4d;

import org.scijava.vecmath.Vector3d;

import org.scijava.vecmath.Vector4d;

/**

* This class defines a spherical bounding region which is defined by a

* center point and a radius.

*/

public class BoundingSphere extends Bounds {

/**

* The center of the bounding sphere.

*/

final Point3d center;

/**

* The radius of the bounding sphere.

*/

double radius;

/**

* Constructs and initializes a BoundingSphere from a center and radius.

* @param center the center of the bounding sphere

* @param radius the radius of the bounding sphere

*/

public BoundingSphere(Point3d center, double radius) {

boundId = BOUNDING_SPHERE;

this.center = new Point3d(center);

this.radius = radius;

updateBoundsStates();

}

/**

* Constructs and initializes a BoundingSphere with radius = 1 at 0 0 0.

*/

public BoundingSphere() {

boundId = BOUNDING_SPHERE;

center = new Point3d();

radius = 1.0;

}

/**

* Constructs and initializes a BoundingSphere from a bounding object.

* @param boundsObject a bounds object

*/

public BoundingSphere(Bounds boundsObject) {

boundId = BOUNDING_SPHERE;

center = new Point3d();

if (boundsObject == null || boundsObject.boundsIsEmpty) {

setEmptyBounds();

return;

}

if (boundsObject.boundsIsInfinite) {

setInfiniteBounds();

return;

}

if( boundsObject.boundId == BOUNDING_BOX){

BoundingBox box = (BoundingBox)boundsObject;

center.x = (box.upper.x+box.lower.x)/2.0;

center.y = (box.upper.y+box.lower.y)/2.0;

center.z = (box.upper.z+box.lower.z)/2.0;

radius = 0.5*(Math.sqrt((box.upper.x-box.lower.x)*

(box.upper.x-box.lower.x)+

(box.upper.y-box.lower.y)*

(box.upper.y-box.lower.y)+

(box.upper.z-box.lower.z)*

(box.upper.z-box.lower.z)));

} else if (boundsObject.boundId == BOUNDING_SPHERE) {

BoundingSphere sphere = (BoundingSphere)boundsObject;

center.set(sphere.center);

radius = sphere.radius;

} else if(boundsObject.boundId == BOUNDING_POLYTOPE) {

BoundingPolytope polytope = (BoundingPolytope)boundsObject;

double t,dis,dis_sq,rad_sq,oldc_to_new_c;

center.x = polytope.centroid.x;

center.y = polytope.centroid.y;

center.z = polytope.centroid.z;

radius = Math.sqrt( (polytope.verts[0].x - center.x)*

(polytope.verts[0].x - center.x) +

(polytope.verts[0].y - center.y)*

(polytope.verts[0].y - center.y) +

(polytope.verts[0].z - center.z)*

(polytope.verts[0].z - center.z));

for (int i = 1; i < polytope.nVerts; i++) {

rad_sq = radius * radius;

dis_sq = (polytope.verts[i].x - center.x)*

(polytope.verts[i].x - center.x) +

(polytope.verts[i].y - center.y)*

(polytope.verts[i].y - center.y) +

(polytope.verts[i].z - center.z)*

(polytope.verts[i].z - center.z);

// change sphere so one side passes through the point

// and other passes through the old sphere

if( dis_sq > rad_sq) {

dis = Math.sqrt( dis_sq);

radius = (radius + dis)*.5;

oldc_to_new_c = dis - radius;

t = oldc_to_new_c/dis;

center.x = center.x + (polytope.verts[i].x - center.x)*t;

center.y = center.y + (polytope.verts[i].y - center.y)*t;

center.z = center.z + (polytope.verts[i].z - center.z)*t;

}

}

} else {

throw new IllegalArgumentException(J3dI18N.getString("BoundingSphere0"));

}

updateBoundsStates();

}

/**

* Constructs and initializes a BoundingSphere from an array of bounding

* objects.

* @param boundsObjects an array of bounds objects

*/

public BoundingSphere(Bounds[] boundsObjects) {

boundId = BOUNDING_SPHERE;

center = new Point3d();

if (boundsObjects == null || boundsObjects.length <= 0) {

setEmptyBounds();

return;

}

// find first non empty bounds object

int i = 0;

while( boundsObjects[i] == null && i < boundsObjects.length) {

i++;

}

if (i >= boundsObjects.length) { // all bounds objects were empty

setEmptyBounds();

return;

}

this.set(boundsObjects[i++]);

if(boundsIsInfinite)

return;

Point3d[] boxVerts = null;

for(;i<boundsObjects.length;i++) {

if( boundsObjects[i] == null ); // do nothing

else if( boundsObjects[i].boundsIsEmpty); // do nothing

else if( boundsObjects[i].boundsIsInfinite ) {

setInfiniteBounds();

return; // We're done.

}

else if( boundsObjects[i].boundId == BOUNDING_BOX){

BoundingBox b = (BoundingBox)boundsObjects[i];

if (boxVerts == null) {

boxVerts = new Point3d[8];

for (int j = 0; j < 8; j++)

boxVerts[j] = new Point3d();

}

boxVerts[0].set(b.lower.x, b.lower.y, b.lower.z );

boxVerts[1].set(b.lower.x, b.upper.y, b.lower.z );

boxVerts[2].set(b.upper.x, b.lower.y, b.lower.z );

boxVerts[3].set(b.upper.x, b.upper.y, b.lower.z );

boxVerts[4].set(b.lower.x, b.lower.y, b.upper.z );

boxVerts[5].set(b.lower.x, b.upper.y, b.upper.z );

boxVerts[6].set(b.upper.x, b.lower.y, b.upper.z );

boxVerts[7].set(b.upper.x, b.upper.y, b.upper.z );

this.combine(boxVerts);

}

else if( boundsObjects[i].boundId == BOUNDING_SPHERE ) {

double dis, t, d1;

BoundingSphere sphere = (BoundingSphere)boundsObjects[i];

dis = Math.sqrt( (center.x - sphere.center.x)*

(center.x - sphere.center.x) +

(center.y - sphere.center.y)*

(center.y - sphere.center.y) +

(center.z - sphere.center.z)*

(center.z - sphere.center.z) );

if( radius > sphere.radius) {

if( (dis+sphere.radius) > radius) {

d1 = .5*(radius-sphere.radius+dis);

t = d1/dis;

radius = d1+sphere.radius;

center.x = sphere.center.x + (center.x-sphere.center.x)*t;

center.y = sphere.center.y + (center.y-sphere.center.y)*t;

center.z = sphere.center.z + (center.z-sphere.center.z)*t;

}

}else {

if( (dis+radius) <= sphere.radius) {

center.x = sphere.center.x;

center.y = sphere.center.y;

center.z = sphere.center.z;

radius = sphere.radius;

}else {

d1 = .5*(sphere.radius-radius+dis);

t = d1/dis;

radius = d1+radius;

center.x = center.x + (sphere.center.x-center.x)*t;

center.y = center.y + (sphere.center.y-center.y)*t;

center.z = center.z + (sphere.center.z-center.z)*t;

}

}

}

else if(boundsObjects[i].boundId == BOUNDING_POLYTOPE) {

BoundingPolytope polytope = (BoundingPolytope)boundsObjects[i];

this.combine(polytope.verts);

}

else {

if( boundsObjects[i] != null )

throw new IllegalArgumentException(J3dI18N.getString("BoundingSphere0"));

}

}

updateBoundsStates();

}

/**

* Returns the radius of this bounding sphere as a double.

* @return the radius of the bounding sphere

*/

public double getRadius() {

return radius;

}

/**

* Sets the radius of this bounding sphere from a double.

* @param r the new radius for the bounding sphere

*/

public void setRadius(double r) {

radius = r;

updateBoundsStates();

}

/**

* Returns the position of this bounding sphere as a point.

* @param center a Point to receive the center of the bounding sphere

*/

@Override

public void getCenter(Point3d center) {

center.set(this.center);

}

/**

* Sets the position of this bounding sphere from a point.

* @param center a Point defining the new center of the bounding sphere

*/

public void setCenter(Point3d center) {

this.center.set(center);

updateBoundsStates();

}

/**

* Sets the value of this BoundingSphere.

* @param boundsObject another bounds object

*/

@Override

public void set(Bounds boundsObject){

int i;

if (boundsObject == null || boundsObject.boundsIsEmpty) {

setEmptyBounds();

return;

}

if( boundsObject.boundsIsInfinite ) {

setInfiniteBounds();

return;

}

if( boundsObject.boundId == BOUNDING_BOX){

BoundingBox box = (BoundingBox)boundsObject;

center.x = (box.upper.x + box.lower.x )/2.0;

center.y = (box.upper.y + box.lower.y )/2.0;

center.z = (box.upper.z + box.lower.z )/2.0;

radius = 0.5*Math.sqrt((box.upper.x-box.lower.x)*

(box.upper.x-box.lower.x)+

(box.upper.y-box.lower.y)*

(box.upper.y-box.lower.y)+

(box.upper.z-box.lower.z)*

(box.upper.z-box.lower.z));

} else if( boundsObject.boundId == BOUNDING_SPHERE ) {

BoundingSphere sphere = (BoundingSphere)boundsObject;

radius = sphere.radius;

center.x = sphere.center.x;

center.y = sphere.center.y;

center.z = sphere.center.z;

} else if(boundsObject.boundId == BOUNDING_POLYTOPE) {

BoundingPolytope polytope = (BoundingPolytope)boundsObject;

double t,dis,dis_sq,rad_sq,oldc_to_new_c;

center.x = polytope.centroid.x;

center.y = polytope.centroid.y;

center.z = polytope.centroid.z;

radius = Math.sqrt((polytope.verts[0].x - center.x)*

(polytope.verts[0].x - center.x) +

(polytope.verts[0].y - center.y)*

(polytope.verts[0].y - center.y) +

(polytope.verts[0].z - center.z)*

(polytope.verts[0].z - center.z));

for(i=1;i<polytope.nVerts;i++) {

rad_sq = radius * radius;

dis_sq = (polytope.verts[i].x - center.x)*

(polytope.verts[i].x - center.x) +

(polytope.verts[i].y - center.y)*

(polytope.verts[i].y - center.y) +

(polytope.verts[i].z - center.z)*

(polytope.verts[i].z - center.z);

// change sphere so one side passes through the point

// and other passes through the old sphere

if( dis_sq > rad_sq) { // point is outside sphere

dis = Math.sqrt( dis_sq);

radius = (radius + dis)*.5;

oldc_to_new_c = dis - radius;

t = oldc_to_new_c/dis;

center.x = center.x + (polytope.verts[i].x - center.x)*t;

center.y = center.y + (polytope.verts[i].y - center.y)*t;

center.z = center.z + (polytope.verts[i].z - center.z)*t;

}

}

} else {

throw new IllegalArgumentException(J3dI18N.getString("BoundingSphere2"));

}

updateBoundsStates();

}

/**

* Creates a copy of the bounding sphere.

* @return a BoundingSphere

*/

@Override

public Object clone() {

return new BoundingSphere(this.center, this.radius);

}

/**

* Indicates whether the specified <code>bounds</code> object is

* equal to this BoundingSphere object. They are equal if the

* specified <code>bounds</code> object is an instance of

* BoundingSphere and all of the data

* members of <code>bounds</code> are equal to the corresponding

* data members in this BoundingSphere.

* @param bounds the object with which the comparison is made.

* @return true if this BoundingSphere is equal to <code>bounds</code>;

* otherwise false

*

* @since Java 3D 1.2

*/

@Override

public boolean equals(Object bounds) {

try {

BoundingSphere sphere = (BoundingSphere)bounds;

return (center.equals(sphere.center) &&

radius == sphere.radius);

}

catch (NullPointerException e) {

return false;

}

catch (ClassCastException e) {

return false;

}

}

/**

* Returns a hash code value for this BoundingSphere object

* based on the data values in this object. Two different

* BoundingSphere objects with identical data values (i.e.,

* BoundingSphere.equals returns true) will return the same hash

* code value. Two BoundingSphere objects with different data

* members may return the same hash code value, although this is

* not likely.

* @return a hash code value for this BoundingSphere object.

*

* @since Java 3D 1.2

*/

@Override

public int hashCode() {

long bits = 1L;

bits = J3dHash.mixDoubleBits(bits, radius);

bits = J3dHash.mixDoubleBits(bits, center.x);

bits = J3dHash.mixDoubleBits(bits, center.y);

bits = J3dHash.mixDoubleBits(bits, center.z);

return J3dHash.finish(bits);

}

/**

* Combines this bounding sphere with a bounding object so that the

* resulting bounding sphere encloses the original bounding sphere and the

* given bounds object.

* @param boundsObject another bounds object

*/

@Override

public void combine(Bounds boundsObject) {

double t,dis,d1,u,l,x,y,z,oldc_to_new_c;

BoundingSphere sphere;

if((boundsObject == null) || (boundsObject.boundsIsEmpty)

|| (boundsIsInfinite))

return;

if((boundsIsEmpty) || (boundsObject.boundsIsInfinite)) {

this.set(boundsObject);

return;

}

if( boundsObject.boundId == BOUNDING_BOX){

BoundingBox b = (BoundingBox)boundsObject;

// start with point furthest from sphere

u = b.upper.x-center.x;

l = b.lower.x-center.x;

if( u*u > l*l)

x = b.upper.x;

else

x = b.lower.x;

u = b.upper.y-center.y;

l = b.lower.y-center.y;

if( u*u > l*l)

y = b.upper.y;

else

y = b.lower.y;

u = b.upper.z-center.z;

l = b.lower.z-center.z;

if( u*u > l*l)

z = b.upper.z;

else

z = b.lower.z;

dis = Math.sqrt( (x - center.x)*(x - center.x) +

(y - center.y)*(y - center.y) +

(z - center.z)*(z - center.z) );

if( dis > radius) {

radius = (dis + radius)*.5;

oldc_to_new_c = dis - radius;

center.x = (radius*center.x + oldc_to_new_c*x)/dis;

center.y = (radius*center.y + oldc_to_new_c*y)/dis;

center.z = (radius*center.z + oldc_to_new_c*z)/dis;

combinePoint( b.upper.x, b.upper.y, b.upper.z);

combinePoint( b.upper.x, b.upper.y, b.lower.z);

combinePoint( b.upper.x, b.lower.y, b.upper.z);

combinePoint( b.upper.x, b.lower.y, b.lower.z);

combinePoint( b.lower.x, b.upper.y, b.upper.z);

combinePoint( b.lower.x, b.upper.y, b.lower.z);

combinePoint( b.lower.x, b.lower.y, b.upper.z);

combinePoint( b.lower.x, b.lower.y, b.lower.z);

}

} else if( boundsObject.boundId == BOUNDING_SPHERE ) {

sphere = (BoundingSphere)boundsObject;

dis = Math.sqrt( (center.x - sphere.center.x)*

(center.x - sphere.center.x) +

(center.y - sphere.center.y)*

(center.y - sphere.center.y) +

(center.z - sphere.center.z)*

(center.z - sphere.center.z) );

if( radius > sphere.radius) {

if( (dis+sphere.radius) > radius) {

d1 = .5*(radius-sphere.radius+dis);

t = d1/dis;

radius = d1+sphere.radius;

center.x = sphere.center.x + (center.x-sphere.center.x)*t;

center.y = sphere.center.y + (center.y-sphere.center.y)*t;

center.z = sphere.center.z + (center.z-sphere.center.z)*t;

}

}else {

if( (dis+radius) <= sphere.radius) {

center.x = sphere.center.x;

center.y = sphere.center.y;

center.z = sphere.center.z;

radius = sphere.radius;

}else {

d1 = .5*(sphere.radius-radius+dis);

t = d1/dis;

radius = d1+radius;

center.x = center.x + (sphere.center.x-center.x)*t;

center.y = center.y + (sphere.center.y-center.y)*t;

center.z = center.z + (sphere.center.z-center.z)*t;

}

}

} else if(boundsObject.boundId == BOUNDING_POLYTOPE) {

BoundingPolytope polytope = (BoundingPolytope)boundsObject;

this.combine(polytope.verts);

} else {

throw new IllegalArgumentException(J3dI18N.getString("BoundingSphere3"));

}

updateBoundsStates();

}

private void combinePoint( double x, double y, double z) {

double dis,oldc_to_new_c;

dis = Math.sqrt( (x - center.x)*(x - center.x) +

(y - center.y)*(y - center.y) +

(z - center.z)*(z - center.z) );

if( dis > radius) {

radius = (dis + radius)*.5;

oldc_to_new_c = dis - radius;

center.x = (radius*center.x + oldc_to_new_c*x)/dis;

center.y = (radius*center.y + oldc_to_new_c*y)/dis;

center.z = (radius*center.z + oldc_to_new_c*z)/dis;

}

}

/**

* Combines this bounding sphere with an array of bounding objects so that the

* resulting bounding sphere encloses the original bounding sphere and the

* given array of bounds object.

* @param boundsObjects an array of bounds objects

*/

@Override

public void combine(Bounds[] boundsObjects) {

BoundingSphere sphere;

BoundingBox b;

BoundingPolytope polytope;

double t,dis,d1,u,l,x,y,z,oldc_to_new_c;

int i=0;

if((boundsObjects == null) || (boundsObjects.length <= 0)

|| (boundsIsInfinite))

return;

// find first non empty bounds object

while((i<boundsObjects.length) &&

((boundsObjects[i] == null) || boundsObjects[i].boundsIsEmpty)) {

i++;

}

if( i >= boundsObjects.length)

return; // no non empty bounds so do not modify current bounds

if( boundsIsEmpty)

this.set(boundsObjects[i++]);

if(boundsIsInfinite)

return;

for(;i<boundsObjects.length;i++) {

if( boundsObjects[i] == null ); // do nothing

else if( boundsObjects[i].boundsIsEmpty); // do nothing

else if( boundsObjects[i].boundsIsInfinite ) {

setInfiniteBounds();

return; // We're done.

} else if( boundsObjects[i].boundId == BOUNDING_BOX){

b = (BoundingBox)boundsObjects[i];

// start with point furthest from sphere

u = b.upper.x-center.x;

l = b.lower.x-center.x;

if( u*u > l*l)

x = b.upper.x;

else

x = b.lower.x;

u = b.upper.y-center.y;

l = b.lower.y-center.y;

if( u*u > l*l)

y = b.upper.y;

else

y = b.lower.y;

u = b.upper.z-center.z;

l = b.lower.z-center.z;

if( u*u > l*l)

z = b.upper.z;

else

z = b.lower.z;

dis = Math.sqrt( (x - center.x)*(x - center.x) +

(y - center.y)*(y - center.y) +

(z - center.z)*(z - center.z) );

if( dis > radius) {

radius = (dis + radius)*.5;

oldc_to_new_c = dis - radius;

center.x = (radius*center.x + oldc_to_new_c*x)/dis;

center.y = (radius*center.y + oldc_to_new_c*y)/dis;

center.z = (radius*center.z + oldc_to_new_c*z)/dis;

combinePoint( b.upper.x, b.upper.y, b.upper.z);

combinePoint( b.upper.x, b.upper.y, b.lower.z);

combinePoint( b.upper.x, b.lower.y, b.upper.z);

combinePoint( b.upper.x, b.lower.y, b.lower.z);

combinePoint( b.lower.x, b.upper.y, b.upper.z);

combinePoint( b.lower.x, b.upper.y, b.lower.z);

combinePoint( b.lower.x, b.lower.y, b.upper.z);

combinePoint( b.lower.x, b.lower.y, b.lower.z);

}

} else if( boundsObjects[i].boundId == BOUNDING_SPHERE ) {

sphere = (BoundingSphere)boundsObjects[i];

dis = Math.sqrt( (center.x - sphere.center.x)*

(center.x - sphere.center.x) +

(center.y - sphere.center.y)*

(center.y - sphere.center.y) +

(center.z - sphere.center.z)*

(center.z - sphere.center.z) );

if( radius > sphere.radius) {

if( (dis+sphere.radius) > radius) {

d1 = .5*(radius-sphere.radius+dis);

t = d1/dis;

radius = d1+sphere.radius;

center.x = sphere.center.x + (center.x-sphere.center.x)*t;

center.y = sphere.center.y + (center.y-sphere.center.y)*t;

center.z = sphere.center.z + (center.z-sphere.center.z)*t;

}

}else {

if( (dis+radius) <= sphere.radius) {

center.x = sphere.center.x;

center.y = sphere.center.y;

center.z = sphere.center.z;

radius = sphere.radius;

}else {

d1 = .5*(sphere.radius-radius+dis);

t = d1/dis;

radius = d1+radius;

center.x = center.x + (sphere.center.x-center.x)*t;

center.y = center.y + (sphere.center.y-center.y)*t;

center.z = center.z + (sphere.center.z-center.z)*t;

}

}

} else if(boundsObjects[i].boundId == BOUNDING_POLYTOPE) {

polytope = (BoundingPolytope)boundsObjects[i];

this.combine(polytope.verts);

} else {

throw new IllegalArgumentException(J3dI18N.getString("BoundingSphere4"));

}

}

updateBoundsStates();

}

/**

* Combines this bounding sphere with a point.

* @param point a 3D point in space

*/

@Override

public void combine(Point3d point) {

double dis,oldc_to_new_c;

if( boundsIsInfinite) {

return;

}

if( boundsIsEmpty) {

radius = 0.0;

center.x = point.x;

center.y = point.y;

center.z = point.z;

} else {

dis = Math.sqrt( (point.x - center.x)*(point.x - center.x) +

(point.y - center.y)*(point.y - center.y) +

(point.z - center.z)*(point.z - center.z) );

if( dis > radius) {

radius = (dis + radius)*.5;

oldc_to_new_c = dis - radius;

center.x = (radius*center.x + oldc_to_new_c*point.x)/dis;

center.y = (radius*center.y + oldc_to_new_c*point.y)/dis;

center.z = (radius*center.z + oldc_to_new_c*point.z)/dis;

}

}

updateBoundsStates();

}

/**

* Combines this bounding sphere with an array of points.

* @param points an array of 3D points in space

*/

@Override

public void combine(Point3d[] points) {

int i;

double dis,dis_sq,rad_sq,oldc_to_new_c;

if( boundsIsInfinite) {

return;

}

if( boundsIsEmpty ) {

center.x = points[0].x;

center.y = points[0].y;

center.z = points[0].z;

radius = 0.0;

}

for(i=0;i<points.length;i++) {

rad_sq = radius * radius;

dis_sq = (points[i].x - center.x)*(points[i].x - center.x) +

(points[i].y - center.y)*(points[i].y - center.y) +

(points[i].z - center.z)*(points[i].z - center.z);

// change sphere so one side passes through the point and

// other passes through the old sphere

if( dis_sq > rad_sq) {

dis = Math.sqrt( dis_sq);

radius = (radius + dis)*.5;

oldc_to_new_c = dis - radius;

center.x = (radius*center.x + oldc_to_new_c*points[i].x)/dis;

center.y = (radius*center.y + oldc_to_new_c*points[i].y)/dis;

center.z = (radius*center.z + oldc_to_new_c*points[i].z)/dis;

}

}

updateBoundsStates();

}

/**

* Modifies the bounding sphere so that it bounds the volume

* generated by transforming the given bounding object.

* @param boundsObject the bounding object to be transformed

* @param matrix a transformation matrix

*/

@Override

public void transform( Bounds boundsObject, Transform3D matrix) {

if (boundsObject == null || boundsObject.boundsIsEmpty) {

setEmptyBounds();

return;

}

if (boundsObject.boundsIsInfinite) {

setInfiniteBounds();

return;

}

if (boundsObject.boundId == BOUNDING_BOX) {

BoundingBox tmpBox = new BoundingBox(boundsObject);

tmpBox.transform(matrix);

this.set(tmpBox);

}

else if (boundsObject.boundId == BOUNDING_SPHERE) {

this.set(boundsObject);

this.transform(matrix);

}

else if (boundsObject.boundId == BOUNDING_POLYTOPE) {

BoundingPolytope tmpPolytope = new BoundingPolytope(boundsObject);

tmpPolytope.transform(matrix);

this.set(tmpPolytope);

} else {

throw new IllegalArgumentException(J3dI18N.getString("BoundingSphere5"));

}

}

/**

* Transforms this bounding sphere by the given matrix.

*/

@Override

public void transform( Transform3D trans) {

double scale;

if(boundsIsInfinite)

return;

trans.transform(center);

scale = trans.getDistanceScale();

radius = radius * scale;

if (Double.isNaN(radius)) {

setEmptyBounds();

return;

}

}

/**

* Test for intersection with a ray

* @param origin the starting point of the ray

* @param direction the direction of the ray

* @param position3 a point defining the location of the pick w= distance to pick

* @return true or false indicating if an intersection occured

*/

@Override

boolean intersect(Point3d origin, Vector3d direction, Point4d position ) {

if( boundsIsEmpty ) {

return false;

}

if( boundsIsInfinite ) {

position.x = origin.x;

position.y = origin.y;

position.z = origin.z;

position.w = 0.0;

return true;

}

double l2oc,rad2,tca,t2hc,t,invMag;

Vector3d dir = new Vector3d(); // normalized direction of ray

Point3d oc = new Point3d(); // vector from sphere center to ray origin

oc.x = center.x - origin.x;

oc.y = center.y - origin.y;

oc.z = center.z - origin.z;

l2oc = oc.x*oc.x + oc.y*oc.y + oc.z*oc.z; // center to origin squared

rad2 = radius*radius;

if( l2oc < rad2 ){

// System.err.println("ray origin inside sphere" );

return true; // ray origin inside sphere

}

invMag = 1.0/Math.sqrt(direction.x*direction.x +

direction.y*direction.y +

direction.z*direction.z);

dir.x = direction.x*invMag;

dir.y = direction.y*invMag;

dir.z = direction.z*invMag;

tca = oc.x*dir.x + oc.y*dir.y + oc.z*dir.z;

if( tca <= 0.0 ) {

// System.err.println("ray points away from sphere" );

return false; // ray points away from sphere

}

t2hc = rad2 - l2oc + tca*tca;

if( t2hc > 0.0 ){

t = tca - Math.sqrt(t2hc);

// System.err.println("ray hits sphere:"+this.toString()+" t="+t+" direction="+dir );

position.x = origin.x + dir.x*t;

position.y = origin.y + dir.y*t;

position.z = origin.z + dir.z*t;

position.w = t;

return true; // ray hits sphere

}else {

// System.err.println("ray does not hit sphere" );

return false;

}

}

/**

* Test for intersection with a point

* @param point the pick point

* @param position a point defining the location of the pick w= distance to pick

* @return true or false indicating if an intersection occured

*/

@Override

boolean intersect(Point3d point, Point4d position ) {

double x,y,z,dist;

if( boundsIsEmpty ) {

return false;

}

if( boundsIsInfinite ) {

position.x = point.x;

position.y = point.y;

position.z = point.z;

position.w = 0.0;

return true;

}

x = point.x - center.x;

y = point.y - center.y;

z = point.z - center.z;

dist = x*x + y*y + z*z;

if( dist > radius*radius)

return false;

else {

position.x = point.x;

position.y = point.y;

position.z = point.z;

position.w = Math.sqrt(dist);

return true;

}

}

/**

* Test for intersection with a segment

* @param start a point defining the start of the line segment

* @param end a point defining the end of the line segment

* @param position a point defining the location of the pick w= distance to pick

* @return true or false indicating if an intersection occured

*/

@Override

boolean intersect( Point3d start, Point3d end, Point4d position ) {

if( boundsIsEmpty ) {

return false;

}

if( boundsIsInfinite ) {

position.x = start.x;

position.y = start.y;

position.z = start.z;

position.w = 0.0;

return true;

}

double l2oc,rad2,tca,t2hc,invMag,t;

Vector3d dir = new Vector3d(); // normalized direction of ray

Point3d oc = new Point3d(); // vector from sphere center to ray origin

Vector3d direction = new Vector3d();

oc.x = center.x - start.x;

oc.y = center.y - start.y;

oc.z = center.z - start.z;

direction.x = end.x - start.x;

direction.y = end.y - start.y;

direction.z = end.z - start.z;

invMag = 1.0/Math.sqrt( direction.x*direction.x +

direction.y*direction.y +

direction.z*direction.z);

dir.x = direction.x*invMag;

dir.y = direction.y*invMag;

dir.z = direction.z*invMag;

l2oc = oc.x*oc.x + oc.y*oc.y + oc.z*oc.z; // center to origin squared

rad2 = radius*radius;

if( l2oc < rad2 ){

// System.err.println("ray origin inside sphere" );

return true; // ray origin inside sphere

}

tca = oc.x*dir.x + oc.y*dir.y + oc.z*dir.z;

if( tca <= 0.0 ) {

// System.err.println("ray points away from sphere" );

return false; // ray points away from sphere

}

t2hc = rad2 - l2oc + tca*tca;

if( t2hc > 0.0 ){

t = tca - Math.sqrt(t2hc);

if( t*t <= ((end.x-start.x)*(end.x-start.x)+

(end.y-start.y)*(end.y-start.y)+

(end.z-start.z)*(end.z-start.z))){

position.x = start.x + dir.x*t;

position.y = start.y + dir.x*t;

position.z = start.z + dir.x*t;

position.w = t;

return true; // segment hits sphere

}

}

return false;

}

/**

* Test for intersection with a ray.

* @param origin the starting point of the ray

* @param direction the direction of the ray

* @return true or false indicating if an intersection occured

*/

@Override

public boolean intersect(Point3d origin, Vector3d direction ) {

if( boundsIsEmpty ) {

return false;

}

if( boundsIsInfinite ) {

return true;

}