http://git-wip-us.apache.org/repos/asf/commons-math/blob/a7b4803f/src/main/java/org/apache/commons/math3/geometry/spherical/twod/EdgesBuilder.java ---------------------------------------------------------------------- diff --git a/src/main/java/org/apache/commons/math3/geometry/spherical/twod/EdgesBuilder.java b/src/main/java/org/apache/commons/math3/geometry/spherical/twod/EdgesBuilder.java deleted file mode 100644 index 4aa712c..0000000 --- a/src/main/java/org/apache/commons/math3/geometry/spherical/twod/EdgesBuilder.java +++ /dev/null @@ -1,169 +0,0 @@ -/* - * Licensed to the Apache Software Foundation (ASF) under one or more - * contributor license agreements. See the NOTICE file distributed with - * this work for additional information regarding copyright ownership. - * The ASF licenses this file to You under the Apache License, Version 2.0 - * (the "License"); you may not use this file except in compliance with - * the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ -package org.apache.commons.math3.geometry.spherical.twod; - -import java.util.ArrayList; -import java.util.IdentityHashMap; -import java.util.List; -import java.util.Map; - -import org.apache.commons.math3.exception.MathIllegalStateException; -import org.apache.commons.math3.exception.util.LocalizedFormats; -import org.apache.commons.math3.geometry.euclidean.threed.Vector3D; -import org.apache.commons.math3.geometry.partitioning.BSPTree; -import org.apache.commons.math3.geometry.partitioning.BSPTreeVisitor; -import org.apache.commons.math3.geometry.partitioning.BoundaryAttribute; -import org.apache.commons.math3.geometry.spherical.oned.Arc; -import org.apache.commons.math3.geometry.spherical.oned.ArcsSet; -import org.apache.commons.math3.geometry.spherical.oned.S1Point; - -/** Visitor building edges. - * @since 3.3 - */ -class EdgesBuilder implements BSPTreeVisitor<Sphere2D> { - - /** Root of the tree. */ - private final BSPTree<Sphere2D> root; - - /** Tolerance below which points are consider to be identical. */ - private final double tolerance; - - /** Built edges and their associated nodes. */ - private final Map<Edge, BSPTree<Sphere2D>> edgeToNode; - - /** Reversed map. */ - private final Map<BSPTree<Sphere2D>, List<Edge>> nodeToEdgesList; - - /** Simple constructor. - * @param root tree root - * @param tolerance below which points are consider to be identical - */ - public EdgesBuilder(final BSPTree<Sphere2D> root, final double tolerance) { - this.root = root; - this.tolerance = tolerance; - this.edgeToNode = new IdentityHashMap<Edge, BSPTree<Sphere2D>>(); - this.nodeToEdgesList = new IdentityHashMap<BSPTree<Sphere2D>, List<Edge>>(); - } - - /** {@inheritDoc} */ - public Order visitOrder(final BSPTree<Sphere2D> node) { - return Order.MINUS_SUB_PLUS; - } - - /** {@inheritDoc} */ - public void visitInternalNode(final BSPTree<Sphere2D> node) { - nodeToEdgesList.put(node, new ArrayList<Edge>()); - @SuppressWarnings("unchecked") - final BoundaryAttribute<Sphere2D> attribute = (BoundaryAttribute<Sphere2D>) node.getAttribute(); - if (attribute.getPlusOutside() != null) { - addContribution((SubCircle) attribute.getPlusOutside(), false, node); - } - if (attribute.getPlusInside() != null) { - addContribution((SubCircle) attribute.getPlusInside(), true, node); - } - } - - /** {@inheritDoc} */ - public void visitLeafNode(final BSPTree<Sphere2D> node) { - } - - /** Add the contribution of a boundary edge. - * @param sub boundary facet - * @param reversed if true, the facet has the inside on its plus side - * @param node node to which the edge belongs - */ - private void addContribution(final SubCircle sub, final boolean reversed, - final BSPTree<Sphere2D> node) { - final Circle circle = (Circle) sub.getHyperplane(); - final List<Arc> arcs = ((ArcsSet) sub.getRemainingRegion()).asList(); - for (final Arc a : arcs) { - final Vertex start = new Vertex((S2Point) circle.toSpace(new S1Point(a.getInf()))); - final Vertex end = new Vertex((S2Point) circle.toSpace(new S1Point(a.getSup()))); - start.bindWith(circle); - end.bindWith(circle); - final Edge edge; - if (reversed) { - edge = new Edge(end, start, a.getSize(), circle.getReverse()); - } else { - edge = new Edge(start, end, a.getSize(), circle); - } - edgeToNode.put(edge, node); - nodeToEdgesList.get(node).add(edge); - } - } - - /** Get the edge that should naturally follow another one. - * @param previous edge to be continued - * @return other edge, starting where the previous one ends (they - * have not been connected yet) - * @exception MathIllegalStateException if there is not a single other edge - */ - private Edge getFollowingEdge(final Edge previous) - throws MathIllegalStateException { - - // get the candidate nodes - final S2Point point = previous.getEnd().getLocation(); - final List<BSPTree<Sphere2D>> candidates = root.getCloseCuts(point, tolerance); - - // the following edge we are looking for must start from one of the candidates nodes - double closest = tolerance; - Edge following = null; - for (final BSPTree<Sphere2D> node : candidates) { - for (final Edge edge : nodeToEdgesList.get(node)) { - if (edge != previous && edge.getStart().getIncoming() == null) { - final Vector3D edgeStart = edge.getStart().getLocation().getVector(); - final double gap = Vector3D.angle(point.getVector(), edgeStart); - if (gap <= closest) { - closest = gap; - following = edge; - } - } - } - } - - if (following == null) { - final Vector3D previousStart = previous.getStart().getLocation().getVector(); - if (Vector3D.angle(point.getVector(), previousStart) <= tolerance) { - // the edge connects back to itself - return previous; - } - - // this should never happen - throw new MathIllegalStateException(LocalizedFormats.OUTLINE_BOUNDARY_LOOP_OPEN); - - } - - return following; - - } - - /** Get the boundary edges. - * @return boundary edges - * @exception MathIllegalStateException if there is not a single other edge - */ - public List<Edge> getEdges() throws MathIllegalStateException { - - // connect the edges - for (final Edge previous : edgeToNode.keySet()) { - previous.setNextEdge(getFollowingEdge(previous)); - } - - return new ArrayList<Edge>(edgeToNode.keySet()); - - } - -}
http://git-wip-us.apache.org/repos/asf/commons-math/blob/a7b4803f/src/main/java/org/apache/commons/math3/geometry/spherical/twod/PropertiesComputer.java ---------------------------------------------------------------------- diff --git a/src/main/java/org/apache/commons/math3/geometry/spherical/twod/PropertiesComputer.java b/src/main/java/org/apache/commons/math3/geometry/spherical/twod/PropertiesComputer.java deleted file mode 100644 index 9d15b11..0000000 --- a/src/main/java/org/apache/commons/math3/geometry/spherical/twod/PropertiesComputer.java +++ /dev/null @@ -1,173 +0,0 @@ -/* - * Licensed to the Apache Software Foundation (ASF) under one or more - * contributor license agreements. See the NOTICE file distributed with - * this work for additional information regarding copyright ownership. - * The ASF licenses this file to You under the Apache License, Version 2.0 - * (the "License"); you may not use this file except in compliance with - * the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ -package org.apache.commons.math3.geometry.spherical.twod; - -import java.util.ArrayList; -import java.util.List; - -import org.apache.commons.math3.exception.MathInternalError; -import org.apache.commons.math3.geometry.euclidean.threed.Vector3D; -import org.apache.commons.math3.geometry.partitioning.BSPTree; -import org.apache.commons.math3.geometry.partitioning.BSPTreeVisitor; -import org.apache.commons.math3.util.FastMath; -import org.apache.commons.math3.util.MathUtils; - -/** Visitor computing geometrical properties. - * @since 3.3 - */ -class PropertiesComputer implements BSPTreeVisitor<Sphere2D> { - - /** Tolerance below which points are consider to be identical. */ - private final double tolerance; - - /** Summed area. */ - private double summedArea; - - /** Summed barycenter. */ - private Vector3D summedBarycenter; - - /** List of points strictly inside convex cells. */ - private final List<Vector3D> convexCellsInsidePoints; - - /** Simple constructor. - * @param tolerance below which points are consider to be identical - */ - public PropertiesComputer(final double tolerance) { - this.tolerance = tolerance; - this.summedArea = 0; - this.summedBarycenter = Vector3D.ZERO; - this.convexCellsInsidePoints = new ArrayList<Vector3D>(); - } - - /** {@inheritDoc} */ - public Order visitOrder(final BSPTree<Sphere2D> node) { - return Order.MINUS_SUB_PLUS; - } - - /** {@inheritDoc} */ - public void visitInternalNode(final BSPTree<Sphere2D> node) { - // nothing to do here - } - - /** {@inheritDoc} */ - public void visitLeafNode(final BSPTree<Sphere2D> node) { - if ((Boolean) node.getAttribute()) { - - // transform this inside leaf cell into a simple convex polygon - final SphericalPolygonsSet convex = - new SphericalPolygonsSet(node.pruneAroundConvexCell(Boolean.TRUE, - Boolean.FALSE, - null), - tolerance); - - // extract the start of the single loop boundary of the convex cell - final List<Vertex> boundary = convex.getBoundaryLoops(); - if (boundary.size() != 1) { - // this should never happen - throw new MathInternalError(); - } - - // compute the geometrical properties of the convex cell - final double area = convexCellArea(boundary.get(0)); - final Vector3D barycenter = convexCellBarycenter(boundary.get(0)); - convexCellsInsidePoints.add(barycenter); - - // add the cell contribution to the global properties - summedArea += area; - summedBarycenter = new Vector3D(1, summedBarycenter, area, barycenter); - - } - } - - /** Compute convex cell area. - * @param start start vertex of the convex cell boundary - * @return area - */ - private double convexCellArea(final Vertex start) { - - int n = 0; - double sum = 0; - - // loop around the cell - for (Edge e = start.getOutgoing(); n == 0 || e.getStart() != start; e = e.getEnd().getOutgoing()) { - - // find path interior angle at vertex - final Vector3D previousPole = e.getCircle().getPole(); - final Vector3D nextPole = e.getEnd().getOutgoing().getCircle().getPole(); - final Vector3D point = e.getEnd().getLocation().getVector(); - double alpha = FastMath.atan2(Vector3D.dotProduct(nextPole, Vector3D.crossProduct(point, previousPole)), - -Vector3D.dotProduct(nextPole, previousPole)); - if (alpha < 0) { - alpha += MathUtils.TWO_PI; - } - sum += alpha; - n++; - } - - // compute area using extended Girard theorem - // see Spherical Trigonometry: For the Use of Colleges and Schools by I. Todhunter - // article 99 in chapter VIII Area Of a Spherical Triangle. Spherical Excess. - // book available from project Gutenberg at http://www.gutenberg.org/ebooks/19770 - return sum - (n - 2) * FastMath.PI; - - } - - /** Compute convex cell barycenter. - * @param start start vertex of the convex cell boundary - * @return barycenter - */ - private Vector3D convexCellBarycenter(final Vertex start) { - - int n = 0; - Vector3D sumB = Vector3D.ZERO; - - // loop around the cell - for (Edge e = start.getOutgoing(); n == 0 || e.getStart() != start; e = e.getEnd().getOutgoing()) { - sumB = new Vector3D(1, sumB, e.getLength(), e.getCircle().getPole()); - n++; - } - - return sumB.normalize(); - - } - - /** Get the area. - * @return area - */ - public double getArea() { - return summedArea; - } - - /** Get the barycenter. - * @return barycenter - */ - public S2Point getBarycenter() { - if (summedBarycenter.getNormSq() == 0) { - return S2Point.NaN; - } else { - return new S2Point(summedBarycenter); - } - } - - /** Get the points strictly inside convex cells. - * @return points strictly inside convex cells - */ - public List<Vector3D> getConvexCellsInsidePoints() { - return convexCellsInsidePoints; - } - -} http://git-wip-us.apache.org/repos/asf/commons-math/blob/a7b4803f/src/main/java/org/apache/commons/math3/geometry/spherical/twod/S2Point.java ---------------------------------------------------------------------- diff --git a/src/main/java/org/apache/commons/math3/geometry/spherical/twod/S2Point.java b/src/main/java/org/apache/commons/math3/geometry/spherical/twod/S2Point.java deleted file mode 100644 index 677e830..0000000 --- a/src/main/java/org/apache/commons/math3/geometry/spherical/twod/S2Point.java +++ /dev/null @@ -1,237 +0,0 @@ -/* - * Licensed to the Apache Software Foundation (ASF) under one or more - * contributor license agreements. See the NOTICE file distributed with - * this work for additional information regarding copyright ownership. - * The ASF licenses this file to You under the Apache License, Version 2.0 - * (the "License"); you may not use this file except in compliance with - * the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ -package org.apache.commons.math3.geometry.spherical.twod; - -import org.apache.commons.math3.exception.MathArithmeticException; -import org.apache.commons.math3.exception.OutOfRangeException; -import org.apache.commons.math3.geometry.Point; -import org.apache.commons.math3.geometry.Space; -import org.apache.commons.math3.geometry.euclidean.threed.Vector3D; -import org.apache.commons.math3.util.FastMath; -import org.apache.commons.math3.util.MathUtils; - -/** This class represents a point on the 2-sphere. - * <p> - * We use the mathematical convention to use the azimuthal angle \( \theta \) - * in the x-y plane as the first coordinate, and the polar angle \( \varphi \) - * as the second coordinate (see <a - * href="http://mathworld.wolfram.com/SphericalCoordinates.html";>Spherical - * Coordinates</a> in MathWorld). - * </p> - * <p>Instances of this class are guaranteed to be immutable.</p> - * @since 3.3 - */ -public class S2Point implements Point<Sphere2D> { - - /** +I (coordinates: \( \theta = 0, \varphi = \pi/2 \)). */ - public static final S2Point PLUS_I = new S2Point(0, 0.5 * FastMath.PI, Vector3D.PLUS_I); - - /** +J (coordinates: \( \theta = \pi/2, \varphi = \pi/2 \))). */ - public static final S2Point PLUS_J = new S2Point(0.5 * FastMath.PI, 0.5 * FastMath.PI, Vector3D.PLUS_J); - - /** +K (coordinates: \( \theta = any angle, \varphi = 0 \)). */ - public static final S2Point PLUS_K = new S2Point(0, 0, Vector3D.PLUS_K); - - /** -I (coordinates: \( \theta = \pi, \varphi = \pi/2 \)). */ - public static final S2Point MINUS_I = new S2Point(FastMath.PI, 0.5 * FastMath.PI, Vector3D.MINUS_I); - - /** -J (coordinates: \( \theta = 3\pi/2, \varphi = \pi/2 \)). */ - public static final S2Point MINUS_J = new S2Point(1.5 * FastMath.PI, 0.5 * FastMath.PI, Vector3D.MINUS_J); - - /** -K (coordinates: \( \theta = any angle, \varphi = \pi \)). */ - public static final S2Point MINUS_K = new S2Point(0, FastMath.PI, Vector3D.MINUS_K); - - // CHECKSTYLE: stop ConstantName - /** A vector with all coordinates set to NaN. */ - public static final S2Point NaN = new S2Point(Double.NaN, Double.NaN, Vector3D.NaN); - // CHECKSTYLE: resume ConstantName - - /** Serializable UID. */ - private static final long serialVersionUID = 20131218L; - - /** Azimuthal angle \( \theta \) in the x-y plane. */ - private final double theta; - - /** Polar angle \( \varphi \). */ - private final double phi; - - /** Corresponding 3D normalized vector. */ - private final Vector3D vector; - - /** Simple constructor. - * Build a vector from its spherical coordinates - * @param theta azimuthal angle \( \theta \) in the x-y plane - * @param phi polar angle \( \varphi \) - * @see #getTheta() - * @see #getPhi() - * @exception OutOfRangeException if \( \varphi \) is not in the [\( 0; \pi \)] range - */ - public S2Point(final double theta, final double phi) - throws OutOfRangeException { - this(theta, phi, vector(theta, phi)); - } - - /** Simple constructor. - * Build a vector from its underlying 3D vector - * @param vector 3D vector - * @exception MathArithmeticException if vector norm is zero - */ - public S2Point(final Vector3D vector) throws MathArithmeticException { - this(FastMath.atan2(vector.getY(), vector.getX()), Vector3D.angle(Vector3D.PLUS_K, vector), - vector.normalize()); - } - - /** Build a point from its internal components. - * @param theta azimuthal angle \( \theta \) in the x-y plane - * @param phi polar angle \( \varphi \) - * @param vector corresponding vector - */ - private S2Point(final double theta, final double phi, final Vector3D vector) { - this.theta = theta; - this.phi = phi; - this.vector = vector; - } - - /** Build the normalized vector corresponding to spherical coordinates. - * @param theta azimuthal angle \( \theta \) in the x-y plane - * @param phi polar angle \( \varphi \) - * @return normalized vector - * @exception OutOfRangeException if \( \varphi \) is not in the [\( 0; \pi \)] range - */ - private static Vector3D vector(final double theta, final double phi) - throws OutOfRangeException { - - if (phi < 0 || phi > FastMath.PI) { - throw new OutOfRangeException(phi, 0, FastMath.PI); - } - - final double cosTheta = FastMath.cos(theta); - final double sinTheta = FastMath.sin(theta); - final double cosPhi = FastMath.cos(phi); - final double sinPhi = FastMath.sin(phi); - - return new Vector3D(cosTheta * sinPhi, sinTheta * sinPhi, cosPhi); - - } - - /** Get the azimuthal angle \( \theta \) in the x-y plane. - * @return azimuthal angle \( \theta \) in the x-y plane - * @see #S2Point(double, double) - */ - public double getTheta() { - return theta; - } - - /** Get the polar angle \( \varphi \). - * @return polar angle \( \varphi \) - * @see #S2Point(double, double) - */ - public double getPhi() { - return phi; - } - - /** Get the corresponding normalized vector in the 3D euclidean space. - * @return normalized vector - */ - public Vector3D getVector() { - return vector; - } - - /** {@inheritDoc} */ - public Space getSpace() { - return Sphere2D.getInstance(); - } - - /** {@inheritDoc} */ - public boolean isNaN() { - return Double.isNaN(theta) || Double.isNaN(phi); - } - - /** Get the opposite of the instance. - * @return a new vector which is opposite to the instance - */ - public S2Point negate() { - return new S2Point(-theta, FastMath.PI - phi, vector.negate()); - } - - /** {@inheritDoc} */ - public double distance(final Point<Sphere2D> point) { - return distance(this, (S2Point) point); - } - - /** Compute the distance (angular separation) between two points. - * @param p1 first vector - * @param p2 second vector - * @return the angular separation between p1 and p2 - */ - public static double distance(S2Point p1, S2Point p2) { - return Vector3D.angle(p1.vector, p2.vector); - } - - /** - * Test for the equality of two points on the 2-sphere. - * <p> - * If all coordinates of two points are exactly the same, and none are - * <code>Double.NaN</code>, the two points are considered to be equal. - * </p> - * <p> - * <code>NaN</code> coordinates are considered to affect globally the vector - * and be equals to each other - i.e, if either (or all) coordinates of the - * 2D vector are equal to <code>Double.NaN</code>, the 2D vector is equal to - * {@link #NaN}. - * </p> - * - * @param other Object to test for equality to this - * @return true if two points on the 2-sphere objects are equal, false if - * object is null, not an instance of S2Point, or - * not equal to this S2Point instance - * - */ - @Override - public boolean equals(Object other) { - - if (this == other) { - return true; - } - - if (other instanceof S2Point) { - final S2Point rhs = (S2Point) other; - if (rhs.isNaN()) { - return this.isNaN(); - } - - return (theta == rhs.theta) && (phi == rhs.phi); - } - return false; - } - - /** - * Get a hashCode for the 2D vector. - * <p> - * All NaN values have the same hash code.</p> - * - * @return a hash code value for this object - */ - @Override - public int hashCode() { - if (isNaN()) { - return 542; - } - return 134 * (37 * MathUtils.hash(theta) + MathUtils.hash(phi)); - } - -} http://git-wip-us.apache.org/repos/asf/commons-math/blob/a7b4803f/src/main/java/org/apache/commons/math3/geometry/spherical/twod/Sphere2D.java ---------------------------------------------------------------------- diff --git a/src/main/java/org/apache/commons/math3/geometry/spherical/twod/Sphere2D.java b/src/main/java/org/apache/commons/math3/geometry/spherical/twod/Sphere2D.java deleted file mode 100644 index 93ff04e..0000000 --- a/src/main/java/org/apache/commons/math3/geometry/spherical/twod/Sphere2D.java +++ /dev/null @@ -1,80 +0,0 @@ -/* - * Licensed to the Apache Software Foundation (ASF) under one or more - * contributor license agreements. See the NOTICE file distributed with - * this work for additional information regarding copyright ownership. - * The ASF licenses this file to You under the Apache License, Version 2.0 - * (the "License"); you may not use this file except in compliance with - * the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package org.apache.commons.math3.geometry.spherical.twod; - -import java.io.Serializable; - -import org.apache.commons.math3.geometry.Space; -import org.apache.commons.math3.geometry.spherical.oned.Sphere1D; - -/** - * This class implements a two-dimensional sphere (i.e. the regular sphere). - * <p> - * We use here the topologists definition of the 2-sphere (see - * <a href="http://mathworld.wolfram.com/Sphere.html";>Sphere</a> on - * MathWorld), i.e. the 2-sphere is the two-dimensional surface - * defined in 3D as x<sup>2</sup>+y<sup>2</sup>+z<sup>2</sup>=1. - * </p> - * @since 3.3 - */ -public class Sphere2D implements Serializable, Space { - - /** Serializable version identifier. */ - private static final long serialVersionUID = 20131218L; - - /** Private constructor for the singleton. - */ - private Sphere2D() { - } - - /** Get the unique instance. - * @return the unique instance - */ - public static Sphere2D getInstance() { - return LazyHolder.INSTANCE; - } - - /** {@inheritDoc} */ - public int getDimension() { - return 2; - } - - /** {@inheritDoc} */ - public Sphere1D getSubSpace() { - return Sphere1D.getInstance(); - } - - // CHECKSTYLE: stop HideUtilityClassConstructor - /** Holder for the instance. - * <p>We use here the Initialization On Demand Holder Idiom.</p> - */ - private static class LazyHolder { - /** Cached field instance. */ - private static final Sphere2D INSTANCE = new Sphere2D(); - } - // CHECKSTYLE: resume HideUtilityClassConstructor - - /** Handle deserialization of the singleton. - * @return the singleton instance - */ - private Object readResolve() { - // return the singleton instance - return LazyHolder.INSTANCE; - } - -} http://git-wip-us.apache.org/repos/asf/commons-math/blob/a7b4803f/src/main/java/org/apache/commons/math3/geometry/spherical/twod/SphericalPolygonsSet.java ---------------------------------------------------------------------- diff --git a/src/main/java/org/apache/commons/math3/geometry/spherical/twod/SphericalPolygonsSet.java b/src/main/java/org/apache/commons/math3/geometry/spherical/twod/SphericalPolygonsSet.java deleted file mode 100644 index 5fdb1c3..0000000 --- a/src/main/java/org/apache/commons/math3/geometry/spherical/twod/SphericalPolygonsSet.java +++ /dev/null @@ -1,563 +0,0 @@ -/* - * Licensed to the Apache Software Foundation (ASF) under one or more - * contributor license agreements. See the NOTICE file distributed with - * this work for additional information regarding copyright ownership. - * The ASF licenses this file to You under the Apache License, Version 2.0 - * (the "License"); you may not use this file except in compliance with - * the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ -package org.apache.commons.math3.geometry.spherical.twod; - -import java.util.ArrayList; -import java.util.Collection; -import java.util.Collections; -import java.util.Iterator; -import java.util.List; - -import org.apache.commons.math3.exception.MathIllegalStateException; -import org.apache.commons.math3.geometry.enclosing.EnclosingBall; -import org.apache.commons.math3.geometry.enclosing.WelzlEncloser; -import org.apache.commons.math3.geometry.euclidean.threed.Euclidean3D; -import org.apache.commons.math3.geometry.euclidean.threed.Rotation; -import org.apache.commons.math3.geometry.euclidean.threed.SphereGenerator; -import org.apache.commons.math3.geometry.euclidean.threed.Vector3D; -import org.apache.commons.math3.geometry.partitioning.AbstractRegion; -import org.apache.commons.math3.geometry.partitioning.BSPTree; -import org.apache.commons.math3.geometry.partitioning.BoundaryProjection; -import org.apache.commons.math3.geometry.partitioning.RegionFactory; -import org.apache.commons.math3.geometry.partitioning.SubHyperplane; -import org.apache.commons.math3.geometry.spherical.oned.Sphere1D; -import org.apache.commons.math3.util.FastMath; -import org.apache.commons.math3.util.MathUtils; - -/** This class represents a region on the 2-sphere: a set of spherical polygons. - * @since 3.3 - */ -public class SphericalPolygonsSet extends AbstractRegion<Sphere2D, Sphere1D> { - - /** Boundary defined as an array of closed loops start vertices. */ - private List<Vertex> loops; - - /** Build a polygons set representing the whole real 2-sphere. - * @param tolerance below which points are consider to be identical - */ - public SphericalPolygonsSet(final double tolerance) { - super(tolerance); - } - - /** Build a polygons set representing a hemisphere. - * @param pole pole of the hemisphere (the pole is in the inside half) - * @param tolerance below which points are consider to be identical - */ - public SphericalPolygonsSet(final Vector3D pole, final double tolerance) { - super(new BSPTree<Sphere2D>(new Circle(pole, tolerance).wholeHyperplane(), - new BSPTree<Sphere2D>(Boolean.FALSE), - new BSPTree<Sphere2D>(Boolean.TRUE), - null), - tolerance); - } - - /** Build a polygons set representing a regular polygon. - * @param center center of the polygon (the center is in the inside half) - * @param meridian point defining the reference meridian for first polygon vertex - * @param outsideRadius distance of the vertices to the center - * @param n number of sides of the polygon - * @param tolerance below which points are consider to be identical - */ - public SphericalPolygonsSet(final Vector3D center, final Vector3D meridian, - final double outsideRadius, final int n, - final double tolerance) { - this(tolerance, createRegularPolygonVertices(center, meridian, outsideRadius, n)); - } - - /** Build a polygons set from a BSP tree. - * <p>The leaf nodes of the BSP tree <em>must</em> have a - * {@code Boolean} attribute representing the inside status of - * the corresponding cell (true for inside cells, false for outside - * cells). In order to avoid building too many small objects, it is - * recommended to use the predefined constants - * {@code Boolean.TRUE} and {@code Boolean.FALSE}</p> - * @param tree inside/outside BSP tree representing the region - * @param tolerance below which points are consider to be identical - */ - public SphericalPolygonsSet(final BSPTree<Sphere2D> tree, final double tolerance) { - super(tree, tolerance); - } - - /** Build a polygons set from a Boundary REPresentation (B-rep). - * <p>The boundary is provided as a collection of {@link - * SubHyperplane sub-hyperplanes}. Each sub-hyperplane has the - * interior part of the region on its minus side and the exterior on - * its plus side.</p> - * <p>The boundary elements can be in any order, and can form - * several non-connected sets (like for example polygons with holes - * or a set of disjoint polygons considered as a whole). In - * fact, the elements do not even need to be connected together - * (their topological connections are not used here). However, if the - * boundary does not really separate an inside open from an outside - * open (open having here its topological meaning), then subsequent - * calls to the {@link - * org.apache.commons.math3.geometry.partitioning.Region#checkPoint(org.apache.commons.math3.geometry.Point) - * checkPoint} method will not be meaningful anymore.</p> - * <p>If the boundary is empty, the region will represent the whole - * space.</p> - * @param boundary collection of boundary elements, as a - * collection of {@link SubHyperplane SubHyperplane} objects - * @param tolerance below which points are consider to be identical - */ - public SphericalPolygonsSet(final Collection<SubHyperplane<Sphere2D>> boundary, final double tolerance) { - super(boundary, tolerance); - } - - /** Build a polygon from a simple list of vertices. - * <p>The boundary is provided as a list of points considering to - * represent the vertices of a simple loop. The interior part of the - * region is on the left side of this path and the exterior is on its - * right side.</p> - * <p>This constructor does not handle polygons with a boundary - * forming several disconnected paths (such as polygons with holes).</p> - * <p>For cases where this simple constructor applies, it is expected to - * be numerically more robust than the {@link #SphericalPolygonsSet(Collection, - * double) general constructor} using {@link SubHyperplane subhyperplanes}.</p> - * <p>If the list is empty, the region will represent the whole - * space.</p> - * <p> - * Polygons with thin pikes or dents are inherently difficult to handle because - * they involve circles with almost opposite directions at some vertices. Polygons - * whose vertices come from some physical measurement with noise are also - * difficult because an edge that should be straight may be broken in lots of - * different pieces with almost equal directions. In both cases, computing the - * circles intersections is not numerically robust due to the almost 0 or almost - * π angle. Such cases need to carefully adjust the {@code hyperplaneThickness} - * parameter. A too small value would often lead to completely wrong polygons - * with large area wrongly identified as inside or outside. Large values are - * often much safer. As a rule of thumb, a value slightly below the size of the - * most accurate detail needed is a good value for the {@code hyperplaneThickness} - * parameter. - * </p> - * @param hyperplaneThickness tolerance below which points are considered to - * belong to the hyperplane (which is therefore more a slab) - * @param vertices vertices of the simple loop boundary - */ - public SphericalPolygonsSet(final double hyperplaneThickness, final S2Point ... vertices) { - super(verticesToTree(hyperplaneThickness, vertices), hyperplaneThickness); - } - - /** Build the vertices representing a regular polygon. - * @param center center of the polygon (the center is in the inside half) - * @param meridian point defining the reference meridian for first polygon vertex - * @param outsideRadius distance of the vertices to the center - * @param n number of sides of the polygon - * @return vertices array - */ - private static S2Point[] createRegularPolygonVertices(final Vector3D center, final Vector3D meridian, - final double outsideRadius, final int n) { - final S2Point[] array = new S2Point[n]; - final Rotation r0 = new Rotation(Vector3D.crossProduct(center, meridian), outsideRadius); - array[0] = new S2Point(r0.applyTo(center)); - - final Rotation r = new Rotation(center, MathUtils.TWO_PI / n); - for (int i = 1; i < n; ++i) { - array[i] = new S2Point(r.applyTo(array[i - 1].getVector())); - } - - return array; - } - - /** Build the BSP tree of a polygons set from a simple list of vertices. - * <p>The boundary is provided as a list of points considering to - * represent the vertices of a simple loop. The interior part of the - * region is on the left side of this path and the exterior is on its - * right side.</p> - * <p>This constructor does not handle polygons with a boundary - * forming several disconnected paths (such as polygons with holes).</p> - * <p>This constructor handles only polygons with edges strictly shorter - * than \( \pi \). If longer edges are needed, they need to be broken up - * in smaller sub-edges so this constraint holds.</p> - * <p>For cases where this simple constructor applies, it is expected to - * be numerically more robust than the {@link #PolygonsSet(Collection) general - * constructor} using {@link SubHyperplane subhyperplanes}.</p> - * @param hyperplaneThickness tolerance below which points are consider to - * belong to the hyperplane (which is therefore more a slab) - * @param vertices vertices of the simple loop boundary - * @return the BSP tree of the input vertices - */ - private static BSPTree<Sphere2D> verticesToTree(final double hyperplaneThickness, - final S2Point ... vertices) { - - final int n = vertices.length; - if (n == 0) { - // the tree represents the whole space - return new BSPTree<Sphere2D>(Boolean.TRUE); - } - - // build the vertices - final Vertex[] vArray = new Vertex[n]; - for (int i = 0; i < n; ++i) { - vArray[i] = new Vertex(vertices[i]); - } - - // build the edges - List<Edge> edges = new ArrayList<Edge>(n); - Vertex end = vArray[n - 1]; - for (int i = 0; i < n; ++i) { - - // get the endpoints of the edge - final Vertex start = end; - end = vArray[i]; - - // get the circle supporting the edge, taking care not to recreate it - // if it was already created earlier due to another edge being aligned - // with the current one - Circle circle = start.sharedCircleWith(end); - if (circle == null) { - circle = new Circle(start.getLocation(), end.getLocation(), hyperplaneThickness); - } - - // create the edge and store it - edges.add(new Edge(start, end, - Vector3D.angle(start.getLocation().getVector(), - end.getLocation().getVector()), - circle)); - - // check if another vertex also happens to be on this circle - for (final Vertex vertex : vArray) { - if (vertex != start && vertex != end && - FastMath.abs(circle.getOffset(vertex.getLocation())) <= hyperplaneThickness) { - vertex.bindWith(circle); - } - } - - } - - // build the tree top-down - final BSPTree<Sphere2D> tree = new BSPTree<Sphere2D>(); - insertEdges(hyperplaneThickness, tree, edges); - - return tree; - - } - - /** Recursively build a tree by inserting cut sub-hyperplanes. - * @param hyperplaneThickness tolerance below which points are considered to - * belong to the hyperplane (which is therefore more a slab) - * @param node current tree node (it is a leaf node at the beginning - * of the call) - * @param edges list of edges to insert in the cell defined by this node - * (excluding edges not belonging to the cell defined by this node) - */ - private static void insertEdges(final double hyperplaneThickness, - final BSPTree<Sphere2D> node, - final List<Edge> edges) { - - // find an edge with an hyperplane that can be inserted in the node - int index = 0; - Edge inserted = null; - while (inserted == null && index < edges.size()) { - inserted = edges.get(index++); - if (!node.insertCut(inserted.getCircle())) { - inserted = null; - } - } - - if (inserted == null) { - // no suitable edge was found, the node remains a leaf node - // we need to set its inside/outside boolean indicator - final BSPTree<Sphere2D> parent = node.getParent(); - if (parent == null || node == parent.getMinus()) { - node.setAttribute(Boolean.TRUE); - } else { - node.setAttribute(Boolean.FALSE); - } - return; - } - - // we have split the node by inserting an edge as a cut sub-hyperplane - // distribute the remaining edges in the two sub-trees - final List<Edge> outsideList = new ArrayList<Edge>(); - final List<Edge> insideList = new ArrayList<Edge>(); - for (final Edge edge : edges) { - if (edge != inserted) { - edge.split(inserted.getCircle(), outsideList, insideList); - } - } - - // recurse through lower levels - if (!outsideList.isEmpty()) { - insertEdges(hyperplaneThickness, node.getPlus(), outsideList); - } else { - node.getPlus().setAttribute(Boolean.FALSE); - } - if (!insideList.isEmpty()) { - insertEdges(hyperplaneThickness, node.getMinus(), insideList); - } else { - node.getMinus().setAttribute(Boolean.TRUE); - } - - } - - /** {@inheritDoc} */ - @Override - public SphericalPolygonsSet buildNew(final BSPTree<Sphere2D> tree) { - return new SphericalPolygonsSet(tree, getTolerance()); - } - - /** {@inheritDoc} - * @exception MathIllegalStateException if the tolerance setting does not allow to build - * a clean non-ambiguous boundary - */ - @Override - protected void computeGeometricalProperties() throws MathIllegalStateException { - - final BSPTree<Sphere2D> tree = getTree(true); - - if (tree.getCut() == null) { - - // the instance has a single cell without any boundaries - - if (tree.getCut() == null && (Boolean) tree.getAttribute()) { - // the instance covers the whole space - setSize(4 * FastMath.PI); - setBarycenter(new S2Point(0, 0)); - } else { - setSize(0); - setBarycenter(S2Point.NaN); - } - - } else { - - // the instance has a boundary - final PropertiesComputer pc = new PropertiesComputer(getTolerance()); - tree.visit(pc); - setSize(pc.getArea()); - setBarycenter(pc.getBarycenter()); - - } - - } - - /** Get the boundary loops of the polygon. - * <p>The polygon boundary can be represented as a list of closed loops, - * each loop being given by exactly one of its vertices. From each loop - * start vertex, one can follow the loop by finding the outgoing edge, - * then the end vertex, then the next outgoing edge ... until the start - * vertex of the loop (exactly the same instance) is found again once - * the full loop has been visited.</p> - * <p>If the polygon has no boundary at all, a zero length loop - * array will be returned.</p> - * <p>If the polygon is a simple one-piece polygon, then the returned - * array will contain a single vertex. - * </p> - * <p>All edges in the various loops have the inside of the region on - * their left side (i.e. toward their pole) and the outside on their - * right side (i.e. away from their pole) when moving in the underlying - * circle direction. This means that the closed loops obey the direct - * trigonometric orientation.</p> - * @return boundary of the polygon, organized as an unmodifiable list of loops start vertices. - * @exception MathIllegalStateException if the tolerance setting does not allow to build - * a clean non-ambiguous boundary - * @see Vertex - * @see Edge - */ - public List<Vertex> getBoundaryLoops() throws MathIllegalStateException { - - if (loops == null) { - if (getTree(false).getCut() == null) { - loops = Collections.emptyList(); - } else { - - // sort the arcs according to their start point - final BSPTree<Sphere2D> root = getTree(true); - final EdgesBuilder visitor = new EdgesBuilder(root, getTolerance()); - root.visit(visitor); - final List<Edge> edges = visitor.getEdges(); - - - // convert the list of all edges into a list of start vertices - loops = new ArrayList<Vertex>(); - while (!edges.isEmpty()) { - - // this is an edge belonging to a new loop, store it - Edge edge = edges.get(0); - final Vertex startVertex = edge.getStart(); - loops.add(startVertex); - - // remove all remaining edges in the same loop - do { - - // remove one edge - for (final Iterator<Edge> iterator = edges.iterator(); iterator.hasNext();) { - if (iterator.next() == edge) { - iterator.remove(); - break; - } - } - - // go to next edge following the boundary loop - edge = edge.getEnd().getOutgoing(); - - } while (edge.getStart() != startVertex); - - } - - } - } - - return Collections.unmodifiableList(loops); - - } - - /** Get a spherical cap enclosing the polygon. - * <p> - * This method is intended as a first test to quickly identify points - * that are guaranteed to be outside of the region, hence performing a full - * {@link #checkPoint(org.apache.commons.math3.geometry.Vector) checkPoint} - * only if the point status remains undecided after the quick check. It is - * is therefore mostly useful to speed up computation for small polygons with - * complex shapes (say a country boundary on Earth), as the spherical cap will - * be small and hence will reliably identify a large part of the sphere as outside, - * whereas the full check can be more computing intensive. A typical use case is - * therefore: - * </p> - * <pre> - * // compute region, plus an enclosing spherical cap - * SphericalPolygonsSet complexShape = ...; - * EnclosingBall<Sphere2D, S2Point> cap = complexShape.getEnclosingCap(); - * - * // check lots of points - * for (Vector3D p : points) { - * - * final Location l; - * if (cap.contains(p)) { - * // we cannot be sure where the point is - * // we need to perform the full computation - * l = complexShape.checkPoint(v); - * } else { - * // no need to do further computation, - * // we already know the point is outside - * l = Location.OUTSIDE; - * } - * - * // use l ... - * - * } - * </pre> - * <p> - * In the special cases of empty or whole sphere polygons, special - * spherical caps are returned, with angular radius set to negative - * or positive infinity so the {@link - * EnclosingBall#contains(org.apache.commons.math3.geometry.Point) ball.contains(point)} - * method return always false or true. - * </p> - * <p> - * This method is <em>not</em> guaranteed to return the smallest enclosing cap. - * </p> - * @return a spherical cap enclosing the polygon - */ - public EnclosingBall<Sphere2D, S2Point> getEnclosingCap() { - - // handle special cases first - if (isEmpty()) { - return new EnclosingBall<Sphere2D, S2Point>(S2Point.PLUS_K, Double.NEGATIVE_INFINITY); - } - if (isFull()) { - return new EnclosingBall<Sphere2D, S2Point>(S2Point.PLUS_K, Double.POSITIVE_INFINITY); - } - - // as the polygons is neither empty nor full, it has some boundaries and cut hyperplanes - final BSPTree<Sphere2D> root = getTree(false); - if (isEmpty(root.getMinus()) && isFull(root.getPlus())) { - // the polygon covers an hemisphere, and its boundary is one 2Ï long edge - final Circle circle = (Circle) root.getCut().getHyperplane(); - return new EnclosingBall<Sphere2D, S2Point>(new S2Point(circle.getPole()).negate(), - 0.5 * FastMath.PI); - } - if (isFull(root.getMinus()) && isEmpty(root.getPlus())) { - // the polygon covers an hemisphere, and its boundary is one 2Ï long edge - final Circle circle = (Circle) root.getCut().getHyperplane(); - return new EnclosingBall<Sphere2D, S2Point>(new S2Point(circle.getPole()), - 0.5 * FastMath.PI); - } - - // gather some inside points, to be used by the encloser - final List<Vector3D> points = getInsidePoints(); - - // extract points from the boundary loops, to be used by the encloser as well - final List<Vertex> boundary = getBoundaryLoops(); - for (final Vertex loopStart : boundary) { - int count = 0; - for (Vertex v = loopStart; count == 0 || v != loopStart; v = v.getOutgoing().getEnd()) { - ++count; - points.add(v.getLocation().getVector()); - } - } - - // find the smallest enclosing 3D sphere - final SphereGenerator generator = new SphereGenerator(); - final WelzlEncloser<Euclidean3D, Vector3D> encloser = - new WelzlEncloser<Euclidean3D, Vector3D>(getTolerance(), generator); - EnclosingBall<Euclidean3D, Vector3D> enclosing3D = encloser.enclose(points); - final Vector3D[] support3D = enclosing3D.getSupport(); - - // convert to 3D sphere to spherical cap - final double r = enclosing3D.getRadius(); - final double h = enclosing3D.getCenter().getNorm(); - if (h < getTolerance()) { - // the 3D sphere is centered on the unit sphere and covers it - // fall back to a crude approximation, based only on outside convex cells - EnclosingBall<Sphere2D, S2Point> enclosingS2 = - new EnclosingBall<Sphere2D, S2Point>(S2Point.PLUS_K, Double.POSITIVE_INFINITY); - for (Vector3D outsidePoint : getOutsidePoints()) { - final S2Point outsideS2 = new S2Point(outsidePoint); - final BoundaryProjection<Sphere2D> projection = projectToBoundary(outsideS2); - if (FastMath.PI - projection.getOffset() < enclosingS2.getRadius()) { - enclosingS2 = new EnclosingBall<Sphere2D, S2Point>(outsideS2.negate(), - FastMath.PI - projection.getOffset(), - (S2Point) projection.getProjected()); - } - } - return enclosingS2; - } - final S2Point[] support = new S2Point[support3D.length]; - for (int i = 0; i < support3D.length; ++i) { - support[i] = new S2Point(support3D[i]); - } - - final EnclosingBall<Sphere2D, S2Point> enclosingS2 = - new EnclosingBall<Sphere2D, S2Point>(new S2Point(enclosing3D.getCenter()), - FastMath.acos((1 + h * h - r * r) / (2 * h)), - support); - - return enclosingS2; - - } - - /** Gather some inside points. - * @return list of points known to be strictly in all inside convex cells - */ - private List<Vector3D> getInsidePoints() { - final PropertiesComputer pc = new PropertiesComputer(getTolerance()); - getTree(true).visit(pc); - return pc.getConvexCellsInsidePoints(); - } - - /** Gather some outside points. - * @return list of points known to be strictly in all outside convex cells - */ - private List<Vector3D> getOutsidePoints() { - final SphericalPolygonsSet complement = - (SphericalPolygonsSet) new RegionFactory<Sphere2D>().getComplement(this); - final PropertiesComputer pc = new PropertiesComputer(getTolerance()); - complement.getTree(true).visit(pc); - return pc.getConvexCellsInsidePoints(); - } - -} http://git-wip-us.apache.org/repos/asf/commons-math/blob/a7b4803f/src/main/java/org/apache/commons/math3/geometry/spherical/twod/SubCircle.java ---------------------------------------------------------------------- diff --git a/src/main/java/org/apache/commons/math3/geometry/spherical/twod/SubCircle.java b/src/main/java/org/apache/commons/math3/geometry/spherical/twod/SubCircle.java deleted file mode 100644 index fa7fd9c..0000000 --- a/src/main/java/org/apache/commons/math3/geometry/spherical/twod/SubCircle.java +++ /dev/null @@ -1,94 +0,0 @@ -/* - * Licensed to the Apache Software Foundation (ASF) under one or more - * contributor license agreements. See the NOTICE file distributed with - * this work for additional information regarding copyright ownership. - * The ASF licenses this file to You under the Apache License, Version 2.0 - * (the "License"); you may not use this file except in compliance with - * the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ -package org.apache.commons.math3.geometry.spherical.twod; - -import org.apache.commons.math3.geometry.euclidean.threed.Vector3D; -import org.apache.commons.math3.geometry.partitioning.AbstractSubHyperplane; -import org.apache.commons.math3.geometry.partitioning.Hyperplane; -import org.apache.commons.math3.geometry.partitioning.Region; -import org.apache.commons.math3.geometry.partitioning.Side; -import org.apache.commons.math3.geometry.spherical.oned.Arc; -import org.apache.commons.math3.geometry.spherical.oned.ArcsSet; -import org.apache.commons.math3.geometry.spherical.oned.Sphere1D; -import org.apache.commons.math3.util.FastMath; - -/** This class represents a sub-hyperplane for {@link Circle}. - * @since 3.3 - */ -public class SubCircle extends AbstractSubHyperplane<Sphere2D, Sphere1D> { - - /** Simple constructor. - * @param hyperplane underlying hyperplane - * @param remainingRegion remaining region of the hyperplane - */ - public SubCircle(final Hyperplane<Sphere2D> hyperplane, - final Region<Sphere1D> remainingRegion) { - super(hyperplane, remainingRegion); - } - - /** {@inheritDoc} */ - @Override - protected AbstractSubHyperplane<Sphere2D, Sphere1D> buildNew(final Hyperplane<Sphere2D> hyperplane, - final Region<Sphere1D> remainingRegion) { - return new SubCircle(hyperplane, remainingRegion); - } - - /** {@inheritDoc} */ - @Override - public Side side(final Hyperplane<Sphere2D> hyperplane) { - - final Circle thisCircle = (Circle) getHyperplane(); - final Circle otherCircle = (Circle) hyperplane; - final double angle = Vector3D.angle(thisCircle.getPole(), otherCircle.getPole()); - - if (angle < thisCircle.getTolerance() || angle > FastMath.PI - thisCircle.getTolerance()) { - // the two circles are aligned or opposite - return Side.HYPER; - } else { - // the two circles intersect each other - return ((ArcsSet) getRemainingRegion()).side(thisCircle.getInsideArc(otherCircle)); - } - - } - - /** {@inheritDoc} */ - @Override - public SplitSubHyperplane<Sphere2D> split(final Hyperplane<Sphere2D> hyperplane) { - - final Circle thisCircle = (Circle) getHyperplane(); - final Circle otherCircle = (Circle) hyperplane; - final double angle = Vector3D.angle(thisCircle.getPole(), otherCircle.getPole()); - - if (angle < thisCircle.getTolerance()) { - // the two circles are aligned - return new SplitSubHyperplane<Sphere2D>(null, this); - } else if (angle > FastMath.PI - thisCircle.getTolerance()) { - // the two circles are opposite - return new SplitSubHyperplane<Sphere2D>(this, null); - } else { - // the two circles intersect each other - final Arc arc = thisCircle.getInsideArc(otherCircle); - final ArcsSet.Split split = ((ArcsSet) getRemainingRegion()).split(arc); - final ArcsSet plus = split.getPlus(); - final ArcsSet minus = split.getMinus(); - return new SplitSubHyperplane<Sphere2D>(plus == null ? null : new SubCircle(thisCircle.copySelf(), plus), - minus == null ? null : new SubCircle(thisCircle.copySelf(), minus)); - } - - } - -} http://git-wip-us.apache.org/repos/asf/commons-math/blob/a7b4803f/src/main/java/org/apache/commons/math3/geometry/spherical/twod/Vertex.java ---------------------------------------------------------------------- diff --git a/src/main/java/org/apache/commons/math3/geometry/spherical/twod/Vertex.java b/src/main/java/org/apache/commons/math3/geometry/spherical/twod/Vertex.java deleted file mode 100644 index 3003da8..0000000 --- a/src/main/java/org/apache/commons/math3/geometry/spherical/twod/Vertex.java +++ /dev/null @@ -1,124 +0,0 @@ -/* - * Licensed to the Apache Software Foundation (ASF) under one or more - * contributor license agreements. See the NOTICE file distributed with - * this work for additional information regarding copyright ownership. - * The ASF licenses this file to You under the Apache License, Version 2.0 - * (the "License"); you may not use this file except in compliance with - * the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ -package org.apache.commons.math3.geometry.spherical.twod; - -import java.util.ArrayList; -import java.util.List; - -/** Spherical polygons boundary vertex. - * @see SphericalPolygonsSet#getBoundaryLoops() - * @see Edge - * @since 3.3 - */ -public class Vertex { - - /** Vertex location. */ - private final S2Point location; - - /** Incoming edge. */ - private Edge incoming; - - /** Outgoing edge. */ - private Edge outgoing; - - /** Circles bound with this vertex. */ - private final List<Circle> circles; - - /** Build a non-processed vertex not owned by any node yet. - * @param location vertex location - */ - Vertex(final S2Point location) { - this.location = location; - this.incoming = null; - this.outgoing = null; - this.circles = new ArrayList<Circle>(); - } - - /** Get Vertex location. - * @return vertex location - */ - public S2Point getLocation() { - return location; - } - - /** Bind a circle considered to contain this vertex. - * @param circle circle to bind with this vertex - */ - void bindWith(final Circle circle) { - circles.add(circle); - } - - /** Get the common circle bound with both the instance and another vertex, if any. - * <p> - * When two vertices are both bound to the same circle, this means they are - * already handled by node associated with this circle, so there is no need - * to create a cut hyperplane for them. - * </p> - * @param vertex other vertex to check instance against - * @return circle bound with both the instance and another vertex, or null if the - * two vertices do not share a circle yet - */ - Circle sharedCircleWith(final Vertex vertex) { - for (final Circle circle1 : circles) { - for (final Circle circle2 : vertex.circles) { - if (circle1 == circle2) { - return circle1; - } - } - } - return null; - } - - /** Set incoming edge. - * <p> - * The circle supporting the incoming edge is automatically bound - * with the instance. - * </p> - * @param incoming incoming edge - */ - void setIncoming(final Edge incoming) { - this.incoming = incoming; - bindWith(incoming.getCircle()); - } - - /** Get incoming edge. - * @return incoming edge - */ - public Edge getIncoming() { - return incoming; - } - - /** Set outgoing edge. - * <p> - * The circle supporting the outgoing edge is automatically bound - * with the instance. - * </p> - * @param outgoing outgoing edge - */ - void setOutgoing(final Edge outgoing) { - this.outgoing = outgoing; - bindWith(outgoing.getCircle()); - } - - /** Get outgoing edge. - * @return outgoing edge - */ - public Edge getOutgoing() { - return outgoing; - } - -} http://git-wip-us.apache.org/repos/asf/commons-math/blob/a7b4803f/src/main/java/org/apache/commons/math3/geometry/spherical/twod/package-info.java ---------------------------------------------------------------------- diff --git a/src/main/java/org/apache/commons/math3/geometry/spherical/twod/package-info.java b/src/main/java/org/apache/commons/math3/geometry/spherical/twod/package-info.java deleted file mode 100644 index 3f3c5b0..0000000 --- a/src/main/java/org/apache/commons/math3/geometry/spherical/twod/package-info.java +++ /dev/null @@ -1,30 +0,0 @@ -/* - * Licensed to the Apache Software Foundation (ASF) under one or more - * contributor license agreements. See the NOTICE file distributed with - * this work for additional information regarding copyright ownership. - * The ASF licenses this file to You under the Apache License, Version 2.0 - * (the "License"); you may not use this file except in compliance with - * the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ -/** - * - * <p> - * This package provides basic geometry components on the 2-sphere. - * </p> - * <p> - * We use here the topologists definition of the 2-sphere (see - * <a href="http://mathworld.wolfram.com/Sphere.html";>Sphere</a> on - * MathWorld), i.e. the 2-sphere is the two-dimensional surface - * defined in 3D as x<sup>2</sup>+y<sup>2</sup>+z<sup>2</sup>=1. - * </p> - * - */ -package org.apache.commons.math3.geometry.spherical.twod;
