Populate throws declarations for geometry package.
git-svn-id: https://svn.apache.org/repos/asf/commons/proper/math/trunk@1379977 13f79535-47bb-0310-9956-ffa450edef68
This commit is contained in:
Luc Maisonobe
parent
e8e94f5936
commit
9e933debcb
|
|
@ -18,6 +18,8 @@ package org.apache.commons.math3.geometry;
|
|||
|
||||
import java.io.Serializable;
|
||||
|
||||
import org.apache.commons.math3.exception.MathUnsupportedOperationException;
|
||||
|
||||
/** This interface represents a generic space, with affine and vectorial counterparts.
|
||||
* @version $Id$
|
||||
* @see Vector
|
||||
|
|
@ -33,7 +35,9 @@ public interface Space extends Serializable {
|
|||
/** Get the n-1 dimension subspace of this space.
|
||||
* @return n-1 dimension sub-space of this space
|
||||
* @see #getDimension()
|
||||
* @exception MathUnsupportedOperationException for dimension-1 spaces
|
||||
* which do not have sub-spaces
|
||||
*/
|
||||
Space getSubSpace();
|
||||
Space getSubSpace() throws MathUnsupportedOperationException;
|
||||
|
||||
}
|
||||
|
|
|
|||
|
|
@ -19,6 +19,8 @@ package org.apache.commons.math3.geometry;
|
|||
import java.io.Serializable;
|
||||
import java.text.NumberFormat;
|
||||
|
||||
import org.apache.commons.math3.exception.MathArithmeticException;
|
||||
|
||||
/** This interface represents a generic vector in a vectorial space or a point in an affine space.
|
||||
* @param <S> Type of the space.
|
||||
* @version $Id$
|
||||
|
|
@ -91,9 +93,9 @@ public interface Vector<S extends Space> extends Serializable {
|
|||
|
||||
/** Get a normalized vector aligned with the instance.
|
||||
* @return a new normalized vector
|
||||
* @exception ArithmeticException if the norm is zero
|
||||
* @exception MathArithmeticException if the norm is zero
|
||||
*/
|
||||
Vector<S> normalize();
|
||||
Vector<S> normalize() throws MathArithmeticException;
|
||||
|
||||
/** Multiply the instance by a scalar.
|
||||
* @param a scalar
|
||||
|
|
|
|||
|
|
@ -183,7 +183,7 @@ public class Vector1D implements Vector<Euclidean1D> {
|
|||
}
|
||||
|
||||
/** {@inheritDoc} */
|
||||
public Vector1D normalize() {
|
||||
public Vector1D normalize() throws MathArithmeticException {
|
||||
double s = getNorm();
|
||||
if (s == 0) {
|
||||
throw new MathArithmeticException(LocalizedFormats.CANNOT_NORMALIZE_A_ZERO_NORM_VECTOR);
|
||||
|
|
|
|||
|
|
@ -109,7 +109,7 @@ public class Vector1DFormat extends VectorFormat<Euclidean1D> {
|
|||
|
||||
/** {@inheritDoc} */
|
||||
@Override
|
||||
public Vector1D parse(final String source) {
|
||||
public Vector1D parse(final String source) throws MathParseException {
|
||||
ParsePosition parsePosition = new ParsePosition(0);
|
||||
Vector1D result = parse(source, parsePosition);
|
||||
if (parsePosition.getIndex() == 0) {
|
||||
|
|
|
|||
|
|
@ -16,7 +16,9 @@
|
|||
*/
|
||||
package org.apache.commons.math3.geometry.euclidean.threed;
|
||||
|
||||
import org.apache.commons.math3.exception.MathArithmeticException;
|
||||
import org.apache.commons.math3.exception.MathIllegalArgumentException;
|
||||
import org.apache.commons.math3.exception.MathInternalError;
|
||||
import org.apache.commons.math3.exception.util.LocalizedFormats;
|
||||
import org.apache.commons.math3.geometry.Vector;
|
||||
import org.apache.commons.math3.geometry.euclidean.oned.Euclidean1D;
|
||||
|
|
@ -51,7 +53,7 @@ public class Line implements Embedding<Euclidean3D, Euclidean1D> {
|
|||
* @param p2 second point belonging to the line (this can be any point, different from p1)
|
||||
* @exception MathIllegalArgumentException if the points are equal
|
||||
*/
|
||||
public Line(final Vector3D p1, final Vector3D p2) {
|
||||
public Line(final Vector3D p1, final Vector3D p2) throws MathIllegalArgumentException {
|
||||
reset(p1, p2);
|
||||
}
|
||||
|
||||
|
|
@ -70,7 +72,7 @@ public class Line implements Embedding<Euclidean3D, Euclidean1D> {
|
|||
* @param p2 second point belonging to the line (this can be any point, different from p1)
|
||||
* @exception MathIllegalArgumentException if the points are equal
|
||||
*/
|
||||
public void reset(final Vector3D p1, final Vector3D p2) {
|
||||
public void reset(final Vector3D p1, final Vector3D p2) throws MathIllegalArgumentException {
|
||||
final Vector3D delta = p2.subtract(p1);
|
||||
final double norm2 = delta.getNormSq();
|
||||
if (norm2 == 0.0) {
|
||||
|
|
@ -84,7 +86,12 @@ public class Line implements Embedding<Euclidean3D, Euclidean1D> {
|
|||
* @return a new instance, with reversed direction
|
||||
*/
|
||||
public Line revert() {
|
||||
return new Line(zero, zero.subtract(direction));
|
||||
try {
|
||||
return new Line(zero, zero.subtract(direction));
|
||||
} catch (MathIllegalArgumentException miae) {
|
||||
// this should never happen has the instance was already built without error
|
||||
throw new MathInternalError(miae);
|
||||
}
|
||||
}
|
||||
|
||||
/** Get the normalized direction vector.
|
||||
|
|
@ -142,8 +149,13 @@ public class Line implements Embedding<Euclidean3D, Euclidean1D> {
|
|||
* @return true if the lines are similar
|
||||
*/
|
||||
public boolean isSimilarTo(final Line line) {
|
||||
final double angle = Vector3D.angle(direction, line.direction);
|
||||
return ((angle < 1.0e-10) || (angle > (FastMath.PI - 1.0e-10))) && contains(line.zero);
|
||||
try {
|
||||
final double angle = Vector3D.angle(direction, line.direction);
|
||||
return ((angle < 1.0e-10) || (angle > (FastMath.PI - 1.0e-10))) && contains(line.zero);
|
||||
} catch (MathArithmeticException mae) {
|
||||
// this should never happen as directions are non-zero vectors
|
||||
throw new MathInternalError(mae);
|
||||
}
|
||||
}
|
||||
|
||||
/** Check if the instance contains a point.
|
||||
|
|
|
|||
|
|
@ -17,12 +17,14 @@
|
|||
package org.apache.commons.math3.geometry.euclidean.threed;
|
||||
|
||||
import org.apache.commons.math3.exception.MathArithmeticException;
|
||||
import org.apache.commons.math3.exception.MathIllegalArgumentException;
|
||||
import org.apache.commons.math3.exception.MathInternalError;
|
||||
import org.apache.commons.math3.exception.util.LocalizedFormats;
|
||||
import org.apache.commons.math3.geometry.Vector;
|
||||
import org.apache.commons.math3.geometry.euclidean.oned.Vector1D;
|
||||
import org.apache.commons.math3.geometry.euclidean.twod.Euclidean2D;
|
||||
import org.apache.commons.math3.geometry.euclidean.twod.Vector2D;
|
||||
import org.apache.commons.math3.geometry.euclidean.twod.PolygonsSet;
|
||||
import org.apache.commons.math3.geometry.euclidean.twod.Vector2D;
|
||||
import org.apache.commons.math3.geometry.partitioning.Embedding;
|
||||
import org.apache.commons.math3.geometry.partitioning.Hyperplane;
|
||||
import org.apache.commons.math3.util.FastMath;
|
||||
|
|
@ -52,7 +54,7 @@ public class Plane implements Hyperplane<Euclidean3D>, Embedding<Euclidean3D, Eu
|
|||
* @param normal normal direction to the plane
|
||||
* @exception MathArithmeticException if the normal norm is too small
|
||||
*/
|
||||
public Plane(final Vector3D normal) {
|
||||
public Plane(final Vector3D normal) throws MathArithmeticException {
|
||||
setNormal(normal);
|
||||
originOffset = 0;
|
||||
setFrame();
|
||||
|
|
@ -63,7 +65,7 @@ public class Plane implements Hyperplane<Euclidean3D>, Embedding<Euclidean3D, Eu
|
|||
* @param normal normal direction to the plane
|
||||
* @exception MathArithmeticException if the normal norm is too small
|
||||
*/
|
||||
public Plane(final Vector3D p, final Vector3D normal) {
|
||||
public Plane(final Vector3D p, final Vector3D normal) throws MathArithmeticException {
|
||||
setNormal(normal);
|
||||
originOffset = -p.dotProduct(w);
|
||||
setFrame();
|
||||
|
|
@ -77,7 +79,8 @@ public class Plane implements Hyperplane<Euclidean3D>, Embedding<Euclidean3D, Eu
|
|||
* @param p3 third point belonging to the plane
|
||||
* @exception MathArithmeticException if the points do not constitute a plane
|
||||
*/
|
||||
public Plane(final Vector3D p1, final Vector3D p2, final Vector3D p3) {
|
||||
public Plane(final Vector3D p1, final Vector3D p2, final Vector3D p3)
|
||||
throws MathArithmeticException {
|
||||
this(p1, p2.subtract(p1).crossProduct(p3.subtract(p1)));
|
||||
}
|
||||
|
||||
|
|
@ -108,8 +111,9 @@ public class Plane implements Hyperplane<Euclidean3D>, Embedding<Euclidean3D, Eu
|
|||
/** Reset the instance as if built from a point and a normal.
|
||||
* @param p point belonging to the plane
|
||||
* @param normal normal direction to the plane
|
||||
* @exception MathArithmeticException if the normal norm is too small
|
||||
*/
|
||||
public void reset(final Vector3D p, final Vector3D normal) {
|
||||
public void reset(final Vector3D p, final Vector3D normal) throws MathArithmeticException {
|
||||
setNormal(normal);
|
||||
originOffset = -p.dotProduct(w);
|
||||
setFrame();
|
||||
|
|
@ -133,7 +137,7 @@ public class Plane implements Hyperplane<Euclidean3D>, Embedding<Euclidean3D, Eu
|
|||
* @param normal normal direction to the plane (will be copied)
|
||||
* @exception MathArithmeticException if the normal norm is too small
|
||||
*/
|
||||
private void setNormal(final Vector3D normal) {
|
||||
private void setNormal(final Vector3D normal) throws MathArithmeticException {
|
||||
final double norm = normal.getNorm();
|
||||
if (norm < 1.0e-10) {
|
||||
throw new MathArithmeticException(LocalizedFormats.ZERO_NORM);
|
||||
|
|
@ -144,9 +148,14 @@ public class Plane implements Hyperplane<Euclidean3D>, Embedding<Euclidean3D, Eu
|
|||
/** Reset the plane frame.
|
||||
*/
|
||||
private void setFrame() {
|
||||
origin = new Vector3D(-originOffset, w);
|
||||
u = w.orthogonal();
|
||||
v = Vector3D.crossProduct(w, u);
|
||||
try {
|
||||
origin = new Vector3D(-originOffset, w);
|
||||
u = w.orthogonal();
|
||||
v = Vector3D.crossProduct(w, u);
|
||||
} catch (MathArithmeticException mae) {
|
||||
// this should never happen as w is built to be non-zero
|
||||
throw new MathInternalError(mae);
|
||||
}
|
||||
}
|
||||
|
||||
/** Get the origin point of the plane frame.
|
||||
|
|
@ -255,9 +264,14 @@ public class Plane implements Hyperplane<Euclidean3D>, Embedding<Euclidean3D, Eu
|
|||
* @return true if the planes are similar
|
||||
*/
|
||||
public boolean isSimilarTo(final Plane plane) {
|
||||
final double angle = Vector3D.angle(w, plane.w);
|
||||
return ((angle < 1.0e-10) && (FastMath.abs(originOffset - plane.originOffset) < 1.0e-10)) ||
|
||||
((angle > (FastMath.PI - 1.0e-10)) && (FastMath.abs(originOffset + plane.originOffset) < 1.0e-10));
|
||||
try {
|
||||
final double angle = Vector3D.angle(w, plane.w);
|
||||
return ((angle < 1.0e-10) && (FastMath.abs(originOffset - plane.originOffset) < 1.0e-10)) ||
|
||||
((angle > (FastMath.PI - 1.0e-10)) && (FastMath.abs(originOffset + plane.originOffset) < 1.0e-10));
|
||||
} catch (MathArithmeticException mae) {
|
||||
// this should never happen as w vectors are built to be non-zero
|
||||
throw new MathInternalError(mae);
|
||||
}
|
||||
}
|
||||
|
||||
/** Rotate the plane around the specified point.
|
||||
|
|
@ -268,15 +282,20 @@ public class Plane implements Hyperplane<Euclidean3D>, Embedding<Euclidean3D, Eu
|
|||
*/
|
||||
public Plane rotate(final Vector3D center, final Rotation rotation) {
|
||||
|
||||
final Vector3D delta = origin.subtract(center);
|
||||
final Plane plane = new Plane(center.add(rotation.applyTo(delta)),
|
||||
rotation.applyTo(w));
|
||||
try {
|
||||
final Vector3D delta = origin.subtract(center);
|
||||
final Plane plane = new Plane(center.add(rotation.applyTo(delta)),
|
||||
rotation.applyTo(w));
|
||||
|
||||
// make sure the frame is transformed as desired
|
||||
plane.u = rotation.applyTo(u);
|
||||
plane.v = rotation.applyTo(v);
|
||||
// make sure the frame is transformed as desired
|
||||
plane.u = rotation.applyTo(u);
|
||||
plane.v = rotation.applyTo(v);
|
||||
|
||||
return plane;
|
||||
return plane;
|
||||
} catch (MathArithmeticException mae) {
|
||||
// this should never happen as w vector is built to be non-zero
|
||||
throw new MathInternalError(mae);
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
|
|
@ -287,13 +306,18 @@ public class Plane implements Hyperplane<Euclidean3D>, Embedding<Euclidean3D, Eu
|
|||
*/
|
||||
public Plane translate(final Vector3D translation) {
|
||||
|
||||
final Plane plane = new Plane(origin.add(translation), w);
|
||||
try {
|
||||
final Plane plane = new Plane(origin.add(translation), w);
|
||||
|
||||
// make sure the frame is transformed as desired
|
||||
plane.u = u;
|
||||
plane.v = v;
|
||||
// make sure the frame is transformed as desired
|
||||
plane.u = u;
|
||||
plane.v = v;
|
||||
|
||||
return plane;
|
||||
return plane;
|
||||
} catch (MathArithmeticException mae) {
|
||||
// this should never happen as w vector is built to be non-zero
|
||||
throw new MathInternalError(mae);
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
|
|
@ -319,12 +343,20 @@ public class Plane implements Hyperplane<Euclidean3D>, Embedding<Euclidean3D, Eu
|
|||
* other plane (really a {@link Line Line} instance)
|
||||
*/
|
||||
public Line intersection(final Plane other) {
|
||||
final Vector3D direction = Vector3D.crossProduct(w, other.w);
|
||||
if (direction.getNorm() < 1.0e-10) {
|
||||
return null;
|
||||
try {
|
||||
final Vector3D direction = Vector3D.crossProduct(w, other.w);
|
||||
if (direction.getNorm() < 1.0e-10) {
|
||||
return null;
|
||||
}
|
||||
final Vector3D point = intersection(this, other, new Plane(direction));
|
||||
return new Line(point, point.add(direction));
|
||||
} catch (MathIllegalArgumentException miae) {
|
||||
// this should never happen as direction has been checked to have non-zero norm
|
||||
throw new MathInternalError(miae);
|
||||
} catch (MathArithmeticException mae) {
|
||||
// this should never happen as direction has been checked to have non-zero norm
|
||||
throw new MathInternalError(mae);
|
||||
}
|
||||
final Vector3D point = intersection(this, other, new Plane(direction));
|
||||
return new Line(point, point.add(direction));
|
||||
}
|
||||
|
||||
/** Get the intersection point of three planes.
|
||||
|
|
|
|||
|
|
@ -19,6 +19,9 @@ package org.apache.commons.math3.geometry.euclidean.threed;
|
|||
import java.awt.geom.AffineTransform;
|
||||
import java.util.Collection;
|
||||
|
||||
import org.apache.commons.math3.exception.MathArithmeticException;
|
||||
import org.apache.commons.math3.exception.MathIllegalArgumentException;
|
||||
import org.apache.commons.math3.exception.MathInternalError;
|
||||
import org.apache.commons.math3.geometry.Vector;
|
||||
import org.apache.commons.math3.geometry.euclidean.oned.Euclidean1D;
|
||||
import org.apache.commons.math3.geometry.euclidean.twod.Euclidean2D;
|
||||
|
|
@ -91,17 +94,39 @@ public class PolyhedronsSet extends AbstractRegion<Euclidean3D, Euclidean2D> {
|
|||
* @param zMin low bound along the z direction
|
||||
* @param zMax high bound along the z direction
|
||||
*/
|
||||
@SuppressWarnings("unchecked")
|
||||
public PolyhedronsSet(final double xMin, final double xMax,
|
||||
final double yMin, final double yMax,
|
||||
final double zMin, final double zMax) {
|
||||
this(new RegionFactory<Euclidean3D>().buildConvex(
|
||||
new Plane(new Vector3D(xMin, 0, 0), Vector3D.MINUS_I),
|
||||
new Plane(new Vector3D(xMax, 0, 0), Vector3D.PLUS_I),
|
||||
new Plane(new Vector3D(0, yMin, 0), Vector3D.MINUS_J),
|
||||
new Plane(new Vector3D(0, yMax, 0), Vector3D.PLUS_J),
|
||||
new Plane(new Vector3D(0, 0, zMin), Vector3D.MINUS_K),
|
||||
new Plane(new Vector3D(0, 0, zMax), Vector3D.PLUS_K)).getTree(false));
|
||||
super(buildBoundary(xMin, xMax, yMin, yMax, zMin, zMax));
|
||||
}
|
||||
|
||||
/** Build a parallellepipedic box boundary.
|
||||
* @param xMin low bound along the x direction
|
||||
* @param xMax high bound along the x direction
|
||||
* @param yMin low bound along the y direction
|
||||
* @param yMax high bound along the y direction
|
||||
* @param zMin low bound along the z direction
|
||||
* @param zMax high bound along the z direction
|
||||
* @return boundary tree
|
||||
*/
|
||||
private static BSPTree<Euclidean3D> buildBoundary(final double xMin, final double xMax,
|
||||
final double yMin, final double yMax,
|
||||
final double zMin, final double zMax) {
|
||||
try {
|
||||
final Plane pxMin = new Plane(new Vector3D(xMin, 0, 0), Vector3D.MINUS_I);
|
||||
final Plane pxMax = new Plane(new Vector3D(xMax, 0, 0), Vector3D.PLUS_I);
|
||||
final Plane pyMin = new Plane(new Vector3D(0, yMin, 0), Vector3D.MINUS_J);
|
||||
final Plane pyMax = new Plane(new Vector3D(0, yMax, 0), Vector3D.PLUS_J);
|
||||
final Plane pzMin = new Plane(new Vector3D(0, 0, zMin), Vector3D.MINUS_K);
|
||||
final Plane pzMax = new Plane(new Vector3D(0, 0, zMax), Vector3D.PLUS_K);
|
||||
@SuppressWarnings("unchecked")
|
||||
final Region<Euclidean3D> boundary =
|
||||
new RegionFactory<Euclidean3D>().buildConvex(pxMin, pxMax, pyMin, pyMax, pzMin, pzMax);
|
||||
return boundary.getTree(false);
|
||||
} catch (MathArithmeticException mae) {
|
||||
// this should never happen as provided normals are all non-zero
|
||||
throw new MathInternalError(mae);
|
||||
}
|
||||
}
|
||||
|
||||
/** {@inheritDoc} */
|
||||
|
|
@ -345,16 +370,21 @@ public class PolyhedronsSet extends AbstractRegion<Euclidean3D, Euclidean2D> {
|
|||
final Vector3D p00 = oPlane.getOrigin();
|
||||
final Vector3D p10 = oPlane.toSpace(new Vector2D(1.0, 0.0));
|
||||
final Vector3D p01 = oPlane.toSpace(new Vector2D(0.0, 1.0));
|
||||
final Vector2D tP00 = tPlane.toSubSpace(apply(p00));
|
||||
final Vector2D tP10 = tPlane.toSubSpace(apply(p10));
|
||||
final Vector2D tP01 = tPlane.toSubSpace(apply(p01));
|
||||
final Vector2D tP00 = tPlane.toSubSpace(apply(p00));
|
||||
final Vector2D tP10 = tPlane.toSubSpace(apply(p10));
|
||||
final Vector2D tP01 = tPlane.toSubSpace(apply(p01));
|
||||
final AffineTransform at =
|
||||
new AffineTransform(tP10.getX() - tP00.getX(), tP10.getY() - tP00.getY(),
|
||||
tP01.getX() - tP00.getX(), tP01.getY() - tP00.getY(),
|
||||
tP00.getX(), tP00.getY());
|
||||
|
||||
cachedOriginal = (Plane) original;
|
||||
cachedTransform = org.apache.commons.math3.geometry.euclidean.twod.Line.getTransform(at);
|
||||
try {
|
||||
cachedTransform = org.apache.commons.math3.geometry.euclidean.twod.Line.getTransform(at);
|
||||
} catch (MathIllegalArgumentException miae) {
|
||||
// this should never happen as the transform built on p00, p10, p01 is invertible
|
||||
throw new MathInternalError(miae);
|
||||
}
|
||||
|
||||
}
|
||||
return ((SubLine) sub).applyTransform(cachedTransform);
|
||||
|
|
@ -414,8 +444,13 @@ public class PolyhedronsSet extends AbstractRegion<Euclidean3D, Euclidean2D> {
|
|||
AffineTransform.getTranslateInstance(shift.getX(), shift.getY());
|
||||
|
||||
cachedOriginal = (Plane) original;
|
||||
cachedTransform =
|
||||
org.apache.commons.math3.geometry.euclidean.twod.Line.getTransform(at);
|
||||
try {
|
||||
cachedTransform =
|
||||
org.apache.commons.math3.geometry.euclidean.twod.Line.getTransform(at);
|
||||
} catch (MathIllegalArgumentException miae) {
|
||||
// this should never happen as a translation is always invertible
|
||||
throw new MathInternalError(miae);
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -19,7 +19,9 @@ package org.apache.commons.math3.geometry.euclidean.threed;
|
|||
|
||||
import java.io.Serializable;
|
||||
|
||||
import org.apache.commons.math3.exception.MathArithmeticException;
|
||||
import org.apache.commons.math3.exception.MathIllegalArgumentException;
|
||||
import org.apache.commons.math3.exception.MathInternalError;
|
||||
import org.apache.commons.math3.exception.util.LocalizedFormats;
|
||||
import org.apache.commons.math3.util.FastMath;
|
||||
import org.apache.commons.math3.util.MathArrays;
|
||||
|
|
@ -171,7 +173,7 @@ public class Rotation implements Serializable {
|
|||
* @param angle rotation angle.
|
||||
* @exception MathIllegalArgumentException if the axis norm is zero
|
||||
*/
|
||||
public Rotation(Vector3D axis, double angle) {
|
||||
public Rotation(Vector3D axis, double angle) throws MathIllegalArgumentException {
|
||||
|
||||
double norm = axis.getNorm();
|
||||
if (norm == 0) {
|
||||
|
|
@ -266,11 +268,11 @@ public class Rotation implements Serializable {
|
|||
* @param u2 second vector of the origin pair
|
||||
* @param v1 desired image of u1 by the rotation
|
||||
* @param v2 desired image of u2 by the rotation
|
||||
* @exception MathIllegalArgumentException if the norm of one of the vectors is zero,
|
||||
* @exception MathArithmeticException if the norm of one of the vectors is zero,
|
||||
* or if one of the pair is degenerated (i.e. the vectors of the pair are colinear)
|
||||
*/
|
||||
public Rotation(Vector3D u1, Vector3D u2, Vector3D v1, Vector3D v2)
|
||||
throws MathIllegalArgumentException {
|
||||
throws MathArithmeticException {
|
||||
|
||||
// build orthonormalized base from u1, u2
|
||||
// this fails when vectors are null or colinear, which is forbidden to define a rotation
|
||||
|
|
@ -322,13 +324,13 @@ public class Rotation implements Serializable {
|
|||
|
||||
* @param u origin vector
|
||||
* @param v desired image of u by the rotation
|
||||
* @exception MathIllegalArgumentException if the norm of one of the vectors is zero
|
||||
* @exception MathArithmeticException if the norm of one of the vectors is zero
|
||||
*/
|
||||
public Rotation(Vector3D u, Vector3D v) {
|
||||
public Rotation(Vector3D u, Vector3D v) throws MathArithmeticException {
|
||||
|
||||
double normProduct = u.getNorm() * v.getNorm();
|
||||
if (normProduct == 0) {
|
||||
throw new MathIllegalArgumentException(LocalizedFormats.ZERO_NORM_FOR_ROTATION_DEFINING_VECTOR);
|
||||
throw new MathArithmeticException(LocalizedFormats.ZERO_NORM_FOR_ROTATION_DEFINING_VECTOR);
|
||||
}
|
||||
|
||||
double dot = u.dotProduct(v);
|
||||
|
|
@ -375,14 +377,20 @@ public class Rotation implements Serializable {
|
|||
*/
|
||||
public Rotation(RotationOrder order,
|
||||
double alpha1, double alpha2, double alpha3) {
|
||||
Rotation r1 = new Rotation(order.getA1(), alpha1);
|
||||
Rotation r2 = new Rotation(order.getA2(), alpha2);
|
||||
Rotation r3 = new Rotation(order.getA3(), alpha3);
|
||||
Rotation composed = r1.applyTo(r2.applyTo(r3));
|
||||
q0 = composed.q0;
|
||||
q1 = composed.q1;
|
||||
q2 = composed.q2;
|
||||
q3 = composed.q3;
|
||||
try {
|
||||
Rotation r1 = new Rotation(order.getA1(), alpha1);
|
||||
Rotation r2 = new Rotation(order.getA2(), alpha2);
|
||||
Rotation r3 = new Rotation(order.getA3(), alpha3);
|
||||
Rotation composed = r1.applyTo(r2.applyTo(r3));
|
||||
q0 = composed.q0;
|
||||
q1 = composed.q1;
|
||||
q2 = composed.q2;
|
||||
q3 = composed.q3;
|
||||
} catch (MathIllegalArgumentException miae) {
|
||||
// this should never happen as RotationOrder axes are all normalized,
|
||||
// and hence never null
|
||||
throw new MathInternalError(miae);
|
||||
}
|
||||
}
|
||||
|
||||
/** Convert an orthogonal rotation matrix to a quaternion.
|
||||
|
|
|
|||
|
|
@ -19,6 +19,7 @@ package org.apache.commons.math3.geometry.euclidean.threed;
|
|||
import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
|
||||
import org.apache.commons.math3.exception.MathIllegalArgumentException;
|
||||
import org.apache.commons.math3.geometry.euclidean.oned.Interval;
|
||||
import org.apache.commons.math3.geometry.euclidean.oned.IntervalsSet;
|
||||
import org.apache.commons.math3.geometry.euclidean.oned.Vector1D;
|
||||
|
|
@ -48,15 +49,18 @@ public class SubLine {
|
|||
/** Create a sub-line from two endpoints.
|
||||
* @param start start point
|
||||
* @param end end point
|
||||
* @exception MathIllegalArgumentException if the points are equal
|
||||
*/
|
||||
public SubLine(final Vector3D start, final Vector3D end) {
|
||||
public SubLine(final Vector3D start, final Vector3D end)
|
||||
throws MathIllegalArgumentException {
|
||||
this(new Line(start, end), buildIntervalSet(start, end));
|
||||
}
|
||||
|
||||
/** Create a sub-line from a segment.
|
||||
* @param segment single segment forming the sub-line
|
||||
* @exception MathIllegalArgumentException if the segment endpoints are equal
|
||||
*/
|
||||
public SubLine(final Segment segment) {
|
||||
public SubLine(final Segment segment) throws MathIllegalArgumentException {
|
||||
this(segment.getLine(), buildIntervalSet(segment.getStart(), segment.getEnd()));
|
||||
}
|
||||
|
||||
|
|
@ -126,8 +130,10 @@ public class SubLine {
|
|||
* @param start start point
|
||||
* @param end end point
|
||||
* @return an interval set
|
||||
* @exception MathIllegalArgumentException if the points are equal
|
||||
*/
|
||||
private static IntervalsSet buildIntervalSet(final Vector3D start, final Vector3D end) {
|
||||
private static IntervalsSet buildIntervalSet(final Vector3D start, final Vector3D end)
|
||||
throws MathIllegalArgumentException {
|
||||
final Line line = new Line(start, end);
|
||||
return new IntervalsSet(line.toSubSpace(start).getX(),
|
||||
line.toSubSpace(end).getX());
|
||||
|
|
|
|||
|
|
@ -293,7 +293,7 @@ public class Vector3D implements Serializable, Vector<Euclidean3D> {
|
|||
}
|
||||
|
||||
/** {@inheritDoc} */
|
||||
public Vector3D normalize() {
|
||||
public Vector3D normalize() throws MathArithmeticException {
|
||||
double s = getNorm();
|
||||
if (s == 0) {
|
||||
throw new MathArithmeticException(LocalizedFormats.CANNOT_NORMALIZE_A_ZERO_NORM_VECTOR);
|
||||
|
|
@ -316,7 +316,7 @@ public class Vector3D implements Serializable, Vector<Euclidean3D> {
|
|||
* @return a new normalized vector orthogonal to the instance
|
||||
* @exception MathArithmeticException if the norm of the instance is null
|
||||
*/
|
||||
public Vector3D orthogonal() {
|
||||
public Vector3D orthogonal() throws MathArithmeticException {
|
||||
|
||||
double threshold = 0.6 * getNorm();
|
||||
if (threshold == 0) {
|
||||
|
|
@ -346,7 +346,7 @@ public class Vector3D implements Serializable, Vector<Euclidean3D> {
|
|||
* @return angular separation between v1 and v2
|
||||
* @exception MathArithmeticException if either vector has a null norm
|
||||
*/
|
||||
public static double angle(Vector3D v1, Vector3D v2) {
|
||||
public static double angle(Vector3D v1, Vector3D v2) throws MathArithmeticException {
|
||||
|
||||
double normProduct = v1.getNorm() * v2.getNorm();
|
||||
if (normProduct == 0) {
|
||||
|
|
|
|||
|
|
@ -124,7 +124,7 @@ public class Vector3DFormat extends VectorFormat<Euclidean3D> {
|
|||
* cannot be parsed.
|
||||
*/
|
||||
@Override
|
||||
public Vector3D parse(final String source) {
|
||||
public Vector3D parse(final String source) throws MathParseException {
|
||||
ParsePosition parsePosition = new ParsePosition(0);
|
||||
Vector3D result = parse(source, parsePosition);
|
||||
if (parsePosition.getIndex() == 0) {
|
||||
|
|
|
|||
|
|
@ -221,7 +221,7 @@ public class Vector2D implements Vector<Euclidean2D> {
|
|||
}
|
||||
|
||||
/** {@inheritDoc} */
|
||||
public Vector2D normalize() {
|
||||
public Vector2D normalize() throws MathArithmeticException {
|
||||
double s = getNorm();
|
||||
if (s == 0) {
|
||||
throw new MathArithmeticException(LocalizedFormats.CANNOT_NORMALIZE_A_ZERO_NORM_VECTOR);
|
||||
|
|
|
|||
|
|
@ -112,7 +112,7 @@ public class Vector2DFormat extends VectorFormat<Euclidean2D> {
|
|||
|
||||
/** {@inheritDoc} */
|
||||
@Override
|
||||
public Vector2D parse(final String source) {
|
||||
public Vector2D parse(final String source) throws MathParseException {
|
||||
ParsePosition parsePosition = new ParsePosition(0);
|
||||
Vector2D result = parse(source, parsePosition);
|
||||
if (parsePosition.getIndex() == 0) {
|
||||
|
|
|
|||
|
|
@ -16,6 +16,8 @@
|
|||
*/
|
||||
package org.apache.commons.math3.geometry.euclidean.threed;
|
||||
|
||||
import org.apache.commons.math3.exception.MathArithmeticException;
|
||||
import org.apache.commons.math3.exception.MathIllegalArgumentException;
|
||||
import org.apache.commons.math3.geometry.euclidean.threed.Line;
|
||||
import org.apache.commons.math3.geometry.euclidean.threed.Vector3D;
|
||||
import org.apache.commons.math3.util.FastMath;
|
||||
|
|
@ -25,7 +27,7 @@ import org.junit.Test;
|
|||
public class LineTest {
|
||||
|
||||
@Test
|
||||
public void testContains() {
|
||||
public void testContains() throws MathIllegalArgumentException, MathArithmeticException {
|
||||
Vector3D p1 = new Vector3D(0, 0, 1);
|
||||
Line l = new Line(p1, new Vector3D(0, 0, 2));
|
||||
Assert.assertTrue(l.contains(p1));
|
||||
|
|
@ -39,7 +41,7 @@ public class LineTest {
|
|||
}
|
||||
|
||||
@Test
|
||||
public void testSimilar() {
|
||||
public void testSimilar() throws MathIllegalArgumentException, MathArithmeticException {
|
||||
Vector3D p1 = new Vector3D (1.2, 3.4, -5.8);
|
||||
Vector3D p2 = new Vector3D (3.4, -5.8, 1.2);
|
||||
Line lA = new Line(p1, p2);
|
||||
|
|
@ -49,14 +51,14 @@ public class LineTest {
|
|||
}
|
||||
|
||||
@Test
|
||||
public void testPointDistance() {
|
||||
public void testPointDistance() throws MathIllegalArgumentException {
|
||||
Line l = new Line(new Vector3D(0, 1, 1), new Vector3D(0, 2, 2));
|
||||
Assert.assertEquals(FastMath.sqrt(3.0 / 2.0), l.distance(new Vector3D(1, 0, 1)), 1.0e-10);
|
||||
Assert.assertEquals(0, l.distance(new Vector3D(0, -4, -4)), 1.0e-10);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testLineDistance() {
|
||||
public void testLineDistance() throws MathIllegalArgumentException {
|
||||
Line l = new Line(new Vector3D(0, 1, 1), new Vector3D(0, 2, 2));
|
||||
Assert.assertEquals(1.0,
|
||||
l.distance(new Line(new Vector3D(1, 0, 1), new Vector3D(1, 0, 2))),
|
||||
|
|
@ -82,7 +84,7 @@ public class LineTest {
|
|||
}
|
||||
|
||||
@Test
|
||||
public void testClosest() {
|
||||
public void testClosest() throws MathIllegalArgumentException {
|
||||
Line l = new Line(new Vector3D(0, 1, 1), new Vector3D(0, 2, 2));
|
||||
Assert.assertEquals(0.0,
|
||||
l.closestPoint(new Line(new Vector3D(1, 0, 1), new Vector3D(1, 0, 2))).distance(new Vector3D(0, 0, 0)),
|
||||
|
|
@ -108,7 +110,7 @@ public class LineTest {
|
|||
}
|
||||
|
||||
@Test
|
||||
public void testIntersection() {
|
||||
public void testIntersection() throws MathIllegalArgumentException {
|
||||
Line l = new Line(new Vector3D(0, 1, 1), new Vector3D(0, 2, 2));
|
||||
Assert.assertNull(l.intersection(new Line(new Vector3D(1, 0, 1), new Vector3D(1, 0, 2))));
|
||||
Assert.assertNull(l.intersection(new Line(new Vector3D(-0.5, 0, 0), new Vector3D(-0.5, -1, -1))));
|
||||
|
|
|
|||
|
|
@ -16,6 +16,8 @@
|
|||
*/
|
||||
package org.apache.commons.math3.geometry.euclidean.threed;
|
||||
|
||||
import org.apache.commons.math3.exception.MathArithmeticException;
|
||||
import org.apache.commons.math3.exception.MathIllegalArgumentException;
|
||||
import org.apache.commons.math3.geometry.euclidean.threed.Line;
|
||||
import org.apache.commons.math3.geometry.euclidean.threed.Plane;
|
||||
import org.apache.commons.math3.geometry.euclidean.threed.Rotation;
|
||||
|
|
@ -26,7 +28,7 @@ import org.junit.Test;
|
|||
public class PlaneTest {
|
||||
|
||||
@Test
|
||||
public void testContains() {
|
||||
public void testContains() throws MathArithmeticException {
|
||||
Plane p = new Plane(new Vector3D(0, 0, 1), new Vector3D(0, 0, 1));
|
||||
Assert.assertTrue(p.contains(new Vector3D(0, 0, 1)));
|
||||
Assert.assertTrue(p.contains(new Vector3D(17, -32, 1)));
|
||||
|
|
@ -34,7 +36,7 @@ public class PlaneTest {
|
|||
}
|
||||
|
||||
@Test
|
||||
public void testOffset() {
|
||||
public void testOffset() throws MathArithmeticException {
|
||||
Vector3D p1 = new Vector3D(1, 1, 1);
|
||||
Plane p = new Plane(p1, new Vector3D(0.2, 0, 0));
|
||||
Assert.assertEquals(-5.0, p.getOffset(new Vector3D(-4, 0, 0)), 1.0e-10);
|
||||
|
|
@ -48,13 +50,13 @@ public class PlaneTest {
|
|||
}
|
||||
|
||||
@Test
|
||||
public void testPoint() {
|
||||
public void testPoint() throws MathArithmeticException {
|
||||
Plane p = new Plane(new Vector3D(2, -3, 1), new Vector3D(1, 4, 9));
|
||||
Assert.assertTrue(p.contains(p.getOrigin()));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testThreePoints() {
|
||||
public void testThreePoints() throws MathArithmeticException {
|
||||
Vector3D p1 = new Vector3D(1.2, 3.4, -5.8);
|
||||
Vector3D p2 = new Vector3D(3.4, -5.8, 1.2);
|
||||
Vector3D p3 = new Vector3D(-2.0, 4.3, 0.7);
|
||||
|
|
@ -65,7 +67,7 @@ public class PlaneTest {
|
|||
}
|
||||
|
||||
@Test
|
||||
public void testRotate() {
|
||||
public void testRotate() throws MathArithmeticException, MathIllegalArgumentException {
|
||||
Vector3D p1 = new Vector3D(1.2, 3.4, -5.8);
|
||||
Vector3D p2 = new Vector3D(3.4, -5.8, 1.2);
|
||||
Vector3D p3 = new Vector3D(-2.0, 4.3, 0.7);
|
||||
|
|
@ -90,7 +92,7 @@ public class PlaneTest {
|
|||
}
|
||||
|
||||
@Test
|
||||
public void testTranslate() {
|
||||
public void testTranslate() throws MathArithmeticException {
|
||||
Vector3D p1 = new Vector3D(1.2, 3.4, -5.8);
|
||||
Vector3D p2 = new Vector3D(3.4, -5.8, 1.2);
|
||||
Vector3D p3 = new Vector3D(-2.0, 4.3, 0.7);
|
||||
|
|
@ -114,7 +116,7 @@ public class PlaneTest {
|
|||
}
|
||||
|
||||
@Test
|
||||
public void testIntersection() {
|
||||
public void testIntersection() throws MathArithmeticException, MathIllegalArgumentException {
|
||||
Plane p = new Plane(new Vector3D(1, 2, 3), new Vector3D(-4, 1, -5));
|
||||
Line l = new Line(new Vector3D(0.2, -3.5, 0.7), new Vector3D(1.2, -2.5, -0.3));
|
||||
Vector3D point = p.intersection(l);
|
||||
|
|
@ -125,7 +127,7 @@ public class PlaneTest {
|
|||
}
|
||||
|
||||
@Test
|
||||
public void testIntersection2() {
|
||||
public void testIntersection2() throws MathArithmeticException {
|
||||
Vector3D p1 = new Vector3D (1.2, 3.4, -5.8);
|
||||
Vector3D p2 = new Vector3D (3.4, -5.8, 1.2);
|
||||
Plane pA = new Plane(p1, p2, new Vector3D (-2.0, 4.3, 0.7));
|
||||
|
|
@ -137,7 +139,7 @@ public class PlaneTest {
|
|||
}
|
||||
|
||||
@Test
|
||||
public void testIntersection3() {
|
||||
public void testIntersection3() throws MathArithmeticException {
|
||||
Vector3D reference = new Vector3D (1.2, 3.4, -5.8);
|
||||
Plane p1 = new Plane(reference, new Vector3D(1, 3, 3));
|
||||
Plane p2 = new Plane(reference, new Vector3D(-2, 4, 0));
|
||||
|
|
@ -149,7 +151,7 @@ public class PlaneTest {
|
|||
}
|
||||
|
||||
@Test
|
||||
public void testSimilar() {
|
||||
public void testSimilar() throws MathArithmeticException {
|
||||
Vector3D p1 = new Vector3D (1.2, 3.4, -5.8);
|
||||
Vector3D p2 = new Vector3D (3.4, -5.8, 1.2);
|
||||
Vector3D p3 = new Vector3D (-2.0, 4.3, 0.7);
|
||||
|
|
|
|||
|
|
@ -18,6 +18,8 @@ package org.apache.commons.math3.geometry.euclidean.threed;
|
|||
|
||||
import java.util.ArrayList;
|
||||
|
||||
import org.apache.commons.math3.exception.MathArithmeticException;
|
||||
import org.apache.commons.math3.exception.MathIllegalArgumentException;
|
||||
import org.apache.commons.math3.geometry.euclidean.twod.Euclidean2D;
|
||||
import org.apache.commons.math3.geometry.euclidean.twod.PolygonsSet;
|
||||
import org.apache.commons.math3.geometry.euclidean.twod.SubLine;
|
||||
|
|
@ -74,7 +76,7 @@ public class PolyhedronsSetTest {
|
|||
}
|
||||
|
||||
@Test
|
||||
public void testTetrahedron() {
|
||||
public void testTetrahedron() throws MathArithmeticException {
|
||||
Vector3D vertex1 = new Vector3D(1, 2, 3);
|
||||
Vector3D vertex2 = new Vector3D(2, 2, 4);
|
||||
Vector3D vertex3 = new Vector3D(2, 3, 3);
|
||||
|
|
@ -109,7 +111,7 @@ public class PolyhedronsSetTest {
|
|||
}
|
||||
|
||||
@Test
|
||||
public void testIsometry() {
|
||||
public void testIsometry() throws MathArithmeticException, MathIllegalArgumentException {
|
||||
Vector3D vertex1 = new Vector3D(1.1, 2.2, 3.3);
|
||||
Vector3D vertex2 = new Vector3D(2.0, 2.4, 4.2);
|
||||
Vector3D vertex3 = new Vector3D(2.8, 3.3, 3.7);
|
||||
|
|
@ -234,7 +236,7 @@ public class PolyhedronsSetTest {
|
|||
}
|
||||
|
||||
@Test
|
||||
public void testIssue780() {
|
||||
public void testIssue780() throws MathArithmeticException {
|
||||
float[] coords = {
|
||||
1.000000f, -1.000000f, -1.000000f,
|
||||
1.000000f, -1.000000f, 1.000000f,
|
||||
|
|
|
|||
|
|
@ -51,7 +51,7 @@ public class RotationTest {
|
|||
}
|
||||
|
||||
@Test
|
||||
public void testAxisAngle() {
|
||||
public void testAxisAngle() throws MathIllegalArgumentException {
|
||||
|
||||
Rotation r = new Rotation(new Vector3D(10, 10, 10), 2 * FastMath.PI / 3);
|
||||
checkVector(r.applyTo(Vector3D.PLUS_I), Vector3D.PLUS_J);
|
||||
|
|
@ -90,7 +90,7 @@ public class RotationTest {
|
|||
}
|
||||
|
||||
@Test
|
||||
public void testVectorOnePair() {
|
||||
public void testVectorOnePair() throws MathArithmeticException {
|
||||
|
||||
Vector3D u = new Vector3D(3, 2, 1);
|
||||
Vector3D v = new Vector3D(-4, 2, 2);
|
||||
|
|
@ -102,14 +102,14 @@ public class RotationTest {
|
|||
try {
|
||||
new Rotation(u, Vector3D.ZERO);
|
||||
Assert.fail("an exception should have been thrown");
|
||||
} catch (IllegalArgumentException e) {
|
||||
} catch (MathArithmeticException e) {
|
||||
// expected behavior
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testVectorTwoPairs() {
|
||||
public void testVectorTwoPairs() throws MathArithmeticException {
|
||||
|
||||
Vector3D u1 = new Vector3D(3, 0, 0);
|
||||
Vector3D u2 = new Vector3D(0, 5, 0);
|
||||
|
|
@ -382,7 +382,7 @@ public class RotationTest {
|
|||
}
|
||||
|
||||
@Test
|
||||
public void testQuaternion() {
|
||||
public void testQuaternion() throws MathIllegalArgumentException {
|
||||
|
||||
Rotation r1 = new Rotation(new Vector3D(2, -3, 5), 1.7);
|
||||
double n = 23.5;
|
||||
|
|
@ -404,7 +404,7 @@ public class RotationTest {
|
|||
}
|
||||
|
||||
@Test
|
||||
public void testCompose() {
|
||||
public void testCompose() throws MathIllegalArgumentException {
|
||||
|
||||
Rotation r1 = new Rotation(new Vector3D(2, -3, 5), 1.7);
|
||||
Rotation r2 = new Rotation(new Vector3D(-1, 3, 2), 0.3);
|
||||
|
|
@ -422,7 +422,7 @@ public class RotationTest {
|
|||
}
|
||||
|
||||
@Test
|
||||
public void testComposeInverse() {
|
||||
public void testComposeInverse() throws MathIllegalArgumentException {
|
||||
|
||||
Rotation r1 = new Rotation(new Vector3D(2, -3, 5), 1.7);
|
||||
Rotation r2 = new Rotation(new Vector3D(-1, 3, 2), 0.3);
|
||||
|
|
@ -440,7 +440,7 @@ public class RotationTest {
|
|||
}
|
||||
|
||||
@Test
|
||||
public void testArray() {
|
||||
public void testArray() throws MathIllegalArgumentException {
|
||||
|
||||
Rotation r = new Rotation(new Vector3D(2, -3, 5), 1.7);
|
||||
|
||||
|
|
@ -465,7 +465,7 @@ public class RotationTest {
|
|||
}
|
||||
|
||||
@Test
|
||||
public void testApplyInverseTo() {
|
||||
public void testApplyInverseTo() throws MathIllegalArgumentException {
|
||||
|
||||
Rotation r = new Rotation(new Vector3D(2, -3, 5), 1.7);
|
||||
for (double lambda = 0; lambda < 6.2; lambda += 0.2) {
|
||||
|
|
@ -504,7 +504,7 @@ public class RotationTest {
|
|||
}
|
||||
|
||||
@Test
|
||||
public void testIssue639(){
|
||||
public void testIssue639() throws MathArithmeticException{
|
||||
Vector3D u1 = new Vector3D(-1321008684645961.0 / 268435456.0,
|
||||
-5774608829631843.0 / 268435456.0,
|
||||
-3822921525525679.0 / 4294967296.0);
|
||||
|
|
@ -519,7 +519,7 @@ public class RotationTest {
|
|||
}
|
||||
|
||||
@Test
|
||||
public void testIssue801() {
|
||||
public void testIssue801() throws MathArithmeticException {
|
||||
Vector3D u1 = new Vector3D(0.9999988431610581, -0.0015210774290851095, 0.0);
|
||||
Vector3D u2 = new Vector3D(0.0, 0.0, 1.0);
|
||||
|
||||
|
|
|
|||
|
|
@ -18,6 +18,7 @@ package org.apache.commons.math3.geometry.euclidean.threed;
|
|||
|
||||
import java.util.List;
|
||||
|
||||
import org.apache.commons.math3.exception.MathIllegalArgumentException;
|
||||
import org.apache.commons.math3.geometry.euclidean.oned.Euclidean1D;
|
||||
import org.apache.commons.math3.geometry.euclidean.oned.IntervalsSet;
|
||||
import org.apache.commons.math3.geometry.partitioning.RegionFactory;
|
||||
|
|
@ -27,7 +28,7 @@ import org.junit.Test;
|
|||
public class SubLineTest {
|
||||
|
||||
@Test
|
||||
public void testEndPoints() {
|
||||
public void testEndPoints() throws MathIllegalArgumentException {
|
||||
Vector3D p1 = new Vector3D(-1, -7, 2);
|
||||
Vector3D p2 = new Vector3D(7, -1, 0);
|
||||
Segment segment = new Segment(p1, p2, new Line(p1, p2));
|
||||
|
|
@ -39,7 +40,7 @@ public class SubLineTest {
|
|||
}
|
||||
|
||||
@Test
|
||||
public void testNoEndPoints() {
|
||||
public void testNoEndPoints() throws MathIllegalArgumentException {
|
||||
SubLine wholeLine = new Line(new Vector3D(-1, 7, 2), new Vector3D(7, 1, 0)).wholeLine();
|
||||
List<Segment> segments = wholeLine.getSegments();
|
||||
Assert.assertEquals(1, segments.size());
|
||||
|
|
@ -58,7 +59,7 @@ public class SubLineTest {
|
|||
}
|
||||
|
||||
@Test
|
||||
public void testNoSegments() {
|
||||
public void testNoSegments() throws MathIllegalArgumentException {
|
||||
SubLine empty = new SubLine(new Line(new Vector3D(-1, -7, 2), new Vector3D(7, -1, 0)),
|
||||
(IntervalsSet) new RegionFactory<Euclidean1D>().getComplement(new IntervalsSet()));
|
||||
List<Segment> segments = empty.getSegments();
|
||||
|
|
@ -66,7 +67,7 @@ public class SubLineTest {
|
|||
}
|
||||
|
||||
@Test
|
||||
public void testSeveralSegments() {
|
||||
public void testSeveralSegments() throws MathIllegalArgumentException {
|
||||
SubLine twoSubs = new SubLine(new Line(new Vector3D(-1, -7, 2), new Vector3D(7, -1, 0)),
|
||||
(IntervalsSet) new RegionFactory<Euclidean1D>().union(new IntervalsSet(1, 2),
|
||||
new IntervalsSet(3, 4)));
|
||||
|
|
@ -75,7 +76,7 @@ public class SubLineTest {
|
|||
}
|
||||
|
||||
@Test
|
||||
public void testHalfInfiniteNeg() {
|
||||
public void testHalfInfiniteNeg() throws MathIllegalArgumentException {
|
||||
SubLine empty = new SubLine(new Line(new Vector3D(-1, -7, 2), new Vector3D(7, -1, -2)),
|
||||
new IntervalsSet(Double.NEGATIVE_INFINITY, 0.0));
|
||||
List<Segment> segments = empty.getSegments();
|
||||
|
|
@ -90,7 +91,7 @@ public class SubLineTest {
|
|||
}
|
||||
|
||||
@Test
|
||||
public void testHalfInfinitePos() {
|
||||
public void testHalfInfinitePos() throws MathIllegalArgumentException {
|
||||
SubLine empty = new SubLine(new Line(new Vector3D(-1, -7, 2), new Vector3D(7, -1, -2)),
|
||||
new IntervalsSet(0.0, Double.POSITIVE_INFINITY));
|
||||
List<Segment> segments = empty.getSegments();
|
||||
|
|
@ -105,7 +106,7 @@ public class SubLineTest {
|
|||
}
|
||||
|
||||
@Test
|
||||
public void testIntersectionInsideInside() {
|
||||
public void testIntersectionInsideInside() throws MathIllegalArgumentException {
|
||||
SubLine sub1 = new SubLine(new Vector3D(1, 1, 1), new Vector3D(3, 1, 1));
|
||||
SubLine sub2 = new SubLine(new Vector3D(2, 0, 0), new Vector3D(2, 2, 2));
|
||||
Assert.assertEquals(0.0, new Vector3D(2, 1, 1).distance(sub1.intersection(sub2, true)), 1.0e-12);
|
||||
|
|
@ -113,7 +114,7 @@ public class SubLineTest {
|
|||
}
|
||||
|
||||
@Test
|
||||
public void testIntersectionInsideBoundary() {
|
||||
public void testIntersectionInsideBoundary() throws MathIllegalArgumentException {
|
||||
SubLine sub1 = new SubLine(new Vector3D(1, 1, 1), new Vector3D(3, 1, 1));
|
||||
SubLine sub2 = new SubLine(new Vector3D(2, 0, 0), new Vector3D(2, 1, 1));
|
||||
Assert.assertEquals(0.0, new Vector3D(2, 1, 1).distance(sub1.intersection(sub2, true)), 1.0e-12);
|
||||
|
|
@ -121,7 +122,7 @@ public class SubLineTest {
|
|||
}
|
||||
|
||||
@Test
|
||||
public void testIntersectionInsideOutside() {
|
||||
public void testIntersectionInsideOutside() throws MathIllegalArgumentException {
|
||||
SubLine sub1 = new SubLine(new Vector3D(1, 1, 1), new Vector3D(3, 1, 1));
|
||||
SubLine sub2 = new SubLine(new Vector3D(2, 0, 0), new Vector3D(2, 0.5, 0.5));
|
||||
Assert.assertNull(sub1.intersection(sub2, true));
|
||||
|
|
@ -129,7 +130,7 @@ public class SubLineTest {
|
|||
}
|
||||
|
||||
@Test
|
||||
public void testIntersectionBoundaryBoundary() {
|
||||
public void testIntersectionBoundaryBoundary() throws MathIllegalArgumentException {
|
||||
SubLine sub1 = new SubLine(new Vector3D(1, 1, 1), new Vector3D(2, 1, 1));
|
||||
SubLine sub2 = new SubLine(new Vector3D(2, 0, 0), new Vector3D(2, 1, 1));
|
||||
Assert.assertEquals(0.0, new Vector3D(2, 1, 1).distance(sub1.intersection(sub2, true)), 1.0e-12);
|
||||
|
|
@ -137,7 +138,7 @@ public class SubLineTest {
|
|||
}
|
||||
|
||||
@Test
|
||||
public void testIntersectionBoundaryOutside() {
|
||||
public void testIntersectionBoundaryOutside() throws MathIllegalArgumentException {
|
||||
SubLine sub1 = new SubLine(new Vector3D(1, 1, 1), new Vector3D(2, 1, 1));
|
||||
SubLine sub2 = new SubLine(new Vector3D(2, 0, 0), new Vector3D(2, 0.5, 0.5));
|
||||
Assert.assertNull(sub1.intersection(sub2, true));
|
||||
|
|
@ -145,7 +146,7 @@ public class SubLineTest {
|
|||
}
|
||||
|
||||
@Test
|
||||
public void testIntersectionOutsideOutside() {
|
||||
public void testIntersectionOutsideOutside() throws MathIllegalArgumentException {
|
||||
SubLine sub1 = new SubLine(new Vector3D(1, 1, 1), new Vector3D(1.5, 1, 1));
|
||||
SubLine sub2 = new SubLine(new Vector3D(2, 0, 0), new Vector3D(2, 0.5, 0.5));
|
||||
Assert.assertNull(sub1.intersection(sub2, true));
|
||||
|
|
|
|||
|
|
@ -21,6 +21,7 @@ import java.text.NumberFormat;
|
|||
import java.text.ParsePosition;
|
||||
import java.util.Locale;
|
||||
|
||||
import org.apache.commons.math3.exception.MathParseException;
|
||||
import org.apache.commons.math3.geometry.euclidean.threed.Vector3D;
|
||||
import org.apache.commons.math3.geometry.euclidean.threed.Vector3DFormat;
|
||||
import org.junit.Test;
|
||||
|
|
@ -160,7 +161,7 @@ public abstract class Vector3DFormatAbstractTest {
|
|||
}
|
||||
|
||||
@Test
|
||||
public void testParseSimpleNoDecimals() {
|
||||
public void testParseSimpleNoDecimals() throws MathParseException {
|
||||
String source = "{1; 1; 1}";
|
||||
Vector3D expected = new Vector3D(1, 1, 1);
|
||||
Vector3D actual = vector3DFormat.parse(source);
|
||||
|
|
@ -181,7 +182,7 @@ public abstract class Vector3DFormatAbstractTest {
|
|||
}
|
||||
|
||||
@Test
|
||||
public void testParseSimpleWithDecimals() {
|
||||
public void testParseSimpleWithDecimals() throws MathParseException {
|
||||
String source =
|
||||
"{1" + getDecimalCharacter() +
|
||||
"23; 1" + getDecimalCharacter() +
|
||||
|
|
@ -193,7 +194,7 @@ public abstract class Vector3DFormatAbstractTest {
|
|||
}
|
||||
|
||||
@Test
|
||||
public void testParseSimpleWithDecimalsTrunc() {
|
||||
public void testParseSimpleWithDecimalsTrunc() throws MathParseException {
|
||||
String source =
|
||||
"{1" + getDecimalCharacter() +
|
||||
"2323; 1" + getDecimalCharacter() +
|
||||
|
|
@ -205,7 +206,7 @@ public abstract class Vector3DFormatAbstractTest {
|
|||
}
|
||||
|
||||
@Test
|
||||
public void testParseNegativeX() {
|
||||
public void testParseNegativeX() throws MathParseException {
|
||||
String source =
|
||||
"{-1" + getDecimalCharacter() +
|
||||
"2323; 1" + getDecimalCharacter() +
|
||||
|
|
@ -217,7 +218,7 @@ public abstract class Vector3DFormatAbstractTest {
|
|||
}
|
||||
|
||||
@Test
|
||||
public void testParseNegativeY() {
|
||||
public void testParseNegativeY() throws MathParseException {
|
||||
String source =
|
||||
"{1" + getDecimalCharacter() +
|
||||
"2323; -1" + getDecimalCharacter() +
|
||||
|
|
@ -229,7 +230,7 @@ public abstract class Vector3DFormatAbstractTest {
|
|||
}
|
||||
|
||||
@Test
|
||||
public void testParseNegativeZ() {
|
||||
public void testParseNegativeZ() throws MathParseException {
|
||||
String source =
|
||||
"{1" + getDecimalCharacter() +
|
||||
"2323; 1" + getDecimalCharacter() +
|
||||
|
|
@ -241,7 +242,7 @@ public abstract class Vector3DFormatAbstractTest {
|
|||
}
|
||||
|
||||
@Test
|
||||
public void testParseNegativeAll() {
|
||||
public void testParseNegativeAll() throws MathParseException {
|
||||
String source =
|
||||
"{-1" + getDecimalCharacter() +
|
||||
"2323; -1" + getDecimalCharacter() +
|
||||
|
|
@ -253,7 +254,7 @@ public abstract class Vector3DFormatAbstractTest {
|
|||
}
|
||||
|
||||
@Test
|
||||
public void testParseZeroX() {
|
||||
public void testParseZeroX() throws MathParseException {
|
||||
String source =
|
||||
"{0" + getDecimalCharacter() +
|
||||
"0; -1" + getDecimalCharacter() +
|
||||
|
|
@ -265,7 +266,7 @@ public abstract class Vector3DFormatAbstractTest {
|
|||
}
|
||||
|
||||
@Test
|
||||
public void testParseNonDefaultSetting() {
|
||||
public void testParseNonDefaultSetting() throws MathParseException {
|
||||
String source =
|
||||
"[1" + getDecimalCharacter() +
|
||||
"2323 : 1" + getDecimalCharacter() +
|
||||
|
|
@ -277,21 +278,21 @@ public abstract class Vector3DFormatAbstractTest {
|
|||
}
|
||||
|
||||
@Test
|
||||
public void testParseNan() {
|
||||
public void testParseNan() throws MathParseException {
|
||||
String source = "{(NaN); (NaN); (NaN)}";
|
||||
Vector3D actual = vector3DFormat.parse(source);
|
||||
Assert.assertEquals(Vector3D.NaN, actual);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testParsePositiveInfinity() {
|
||||
public void testParsePositiveInfinity() throws MathParseException {
|
||||
String source = "{(Infinity); (Infinity); (Infinity)}";
|
||||
Vector3D actual = vector3DFormat.parse(source);
|
||||
Assert.assertEquals(Vector3D.POSITIVE_INFINITY, actual);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testParseNegativeInfinity() {
|
||||
public void testParseNegativeInfinity() throws MathParseException {
|
||||
String source = "{(-Infinity); (-Infinity); (-Infinity)}";
|
||||
Vector3D actual = vector3DFormat.parse(source);
|
||||
Assert.assertEquals(Vector3D.NEGATIVE_INFINITY, actual);
|
||||
|
|
|
|||
|
|
@ -26,7 +26,7 @@ import org.junit.Test;
|
|||
|
||||
public class Vector3DTest {
|
||||
@Test
|
||||
public void testConstructors() {
|
||||
public void testConstructors() throws DimensionMismatchException {
|
||||
double r = FastMath.sqrt(2) /2;
|
||||
checkVector(new Vector3D(2, new Vector3D(FastMath.PI / 3, -FastMath.PI / 4)),
|
||||
r, r * FastMath.sqrt(3), -2 * r);
|
||||
|
|
@ -47,7 +47,7 @@ public class Vector3DTest {
|
|||
}
|
||||
|
||||
@Test(expected=DimensionMismatchException.class)
|
||||
public void testWrongDimension() {
|
||||
public void testWrongDimension() throws DimensionMismatchException {
|
||||
new Vector3D(new double[] { 2, 5 });
|
||||
}
|
||||
|
||||
|
|
@ -191,7 +191,7 @@ public class Vector3DTest {
|
|||
}
|
||||
|
||||
@Test
|
||||
public void testAngularSeparation() {
|
||||
public void testAngularSeparation() throws MathArithmeticException {
|
||||
Vector3D v1 = new Vector3D(2, -1, 4);
|
||||
|
||||
Vector3D k = v1.normalize();
|
||||
|
|
@ -202,7 +202,7 @@ public class Vector3DTest {
|
|||
}
|
||||
|
||||
@Test
|
||||
public void testNormalize() {
|
||||
public void testNormalize() throws MathArithmeticException {
|
||||
Assert.assertEquals(1.0, new Vector3D(5, -4, 2).normalize().getNorm(), 1.0e-12);
|
||||
try {
|
||||
Vector3D.ZERO.normalize();
|
||||
|
|
@ -213,7 +213,7 @@ public class Vector3DTest {
|
|||
}
|
||||
|
||||
@Test
|
||||
public void testOrthogonal() {
|
||||
public void testOrthogonal() throws MathArithmeticException {
|
||||
Vector3D v1 = new Vector3D(0.1, 2.5, 1.3);
|
||||
Assert.assertEquals(0.0, Vector3D.dotProduct(v1, v1.orthogonal()), 1.0e-12);
|
||||
Vector3D v2 = new Vector3D(2.3, -0.003, 7.6);
|
||||
|
|
@ -229,7 +229,7 @@ public class Vector3DTest {
|
|||
}
|
||||
|
||||
@Test
|
||||
public void testAngle() {
|
||||
public void testAngle() throws MathArithmeticException {
|
||||
Assert.assertEquals(0.22572612855273393616,
|
||||
Vector3D.angle(new Vector3D(1, 2, 3), new Vector3D(4, 5, 6)),
|
||||
1.0e-12);
|
||||
|
|
|
|||
|
|
@ -16,6 +16,7 @@
|
|||
*/
|
||||
package org.apache.commons.math3.geometry.euclidean.twod;
|
||||
|
||||
import org.apache.commons.math3.exception.MathIllegalArgumentException;
|
||||
import org.apache.commons.math3.geometry.euclidean.oned.Euclidean1D;
|
||||
import org.apache.commons.math3.geometry.euclidean.oned.Vector1D;
|
||||
import org.apache.commons.math3.geometry.euclidean.twod.Line;
|
||||
|
|
@ -98,7 +99,7 @@ public class LineTest {
|
|||
}
|
||||
|
||||
@Test
|
||||
public void testTransform() {
|
||||
public void testTransform() throws MathIllegalArgumentException {
|
||||
|
||||
Line l1 = new Line(new Vector2D(1.0 ,1.0), new Vector2D(4.0 ,1.0));
|
||||
Transform<Euclidean2D, Euclidean1D> t1 =
|
||||
|
|
|
|||
Loading…
Reference in New Issue