http://git-wip-us.apache.org/repos/asf/commons-math/blob/a7b4803f/src/main/java/org/apache/commons/math3/geometry/spherical/oned/Arc.java ---------------------------------------------------------------------- diff --git a/src/main/java/org/apache/commons/math3/geometry/spherical/oned/Arc.java b/src/main/java/org/apache/commons/math3/geometry/spherical/oned/Arc.java deleted file mode 100644 index af0388e..0000000 --- a/src/main/java/org/apache/commons/math3/geometry/spherical/oned/Arc.java +++ /dev/null @@ -1,132 +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.oned; - -import org.apache.commons.math3.exception.NumberIsTooLargeException; -import org.apache.commons.math3.exception.util.LocalizedFormats; -import org.apache.commons.math3.geometry.partitioning.Region.Location; -import org.apache.commons.math3.util.FastMath; -import org.apache.commons.math3.util.MathUtils; -import org.apache.commons.math3.util.Precision; - - -/** This class represents an arc on a circle. - * @see ArcsSet - * @since 3.3 - */ -public class Arc { - - /** The lower angular bound of the arc. */ - private final double lower; - - /** The upper angular bound of the arc. */ - private final double upper; - - /** Middle point of the arc. */ - private final double middle; - - /** Tolerance below which angles are considered identical. */ - private final double tolerance; - - /** Simple constructor. - * <p> - * If either {@code lower} is equals to {@code upper} or - * the interval exceeds \( 2 \pi \), the arc is considered - * to be the full circle and its initial defining boundaries - * will be forgotten. {@code lower} is not allowed to be - * greater than {@code upper} (an exception is thrown in this case). - * {@code lower} will be canonicalized between 0 and \( 2 \pi \), and - * upper shifted accordingly, so the {@link #getInf()} and {@link #getSup()} - * may not return the value used at instance construction. - * </p> - * @param lower lower angular bound of the arc - * @param upper upper angular bound of the arc - * @param tolerance tolerance below which angles are considered identical - * @exception NumberIsTooLargeException if lower is greater than upper - */ - public Arc(final double lower, final double upper, final double tolerance) - throws NumberIsTooLargeException { - this.tolerance = tolerance; - if (Precision.equals(lower, upper, 0) || (upper - lower) >= MathUtils.TWO_PI) { - // the arc must cover the whole circle - this.lower = 0; - this.upper = MathUtils.TWO_PI; - this.middle = FastMath.PI; - } else if (lower <= upper) { - this.lower = MathUtils.normalizeAngle(lower, FastMath.PI); - this.upper = this.lower + (upper - lower); - this.middle = 0.5 * (this.lower + this.upper); - } else { - throw new NumberIsTooLargeException(LocalizedFormats.ENDPOINTS_NOT_AN_INTERVAL, - lower, upper, true); - } - } - - /** Get the lower angular bound of the arc. - * @return lower angular bound of the arc, - * always between 0 and \( 2 \pi \) - */ - public double getInf() { - return lower; - } - - /** Get the upper angular bound of the arc. - * @return upper angular bound of the arc, - * always between {@link #getInf()} and {@link #getInf()} \( + 2 \pi \) - */ - public double getSup() { - return upper; - } - - /** Get the angular size of the arc. - * @return angular size of the arc - */ - public double getSize() { - return upper - lower; - } - - /** Get the barycenter of the arc. - * @return barycenter of the arc - */ - public double getBarycenter() { - return middle; - } - - /** Get the tolerance below which angles are considered identical. - * @return tolerance below which angles are considered identical - */ - public double getTolerance() { - return tolerance; - } - - /** Check a point with respect to the arc. - * @param point point to check - * @return a code representing the point status: either {@link - * Location#INSIDE}, {@link Location#OUTSIDE} or {@link Location#BOUNDARY} - */ - public Location checkPoint(final double point) { - final double normalizedPoint = MathUtils.normalizeAngle(point, middle); - if (normalizedPoint < lower - tolerance || normalizedPoint > upper + tolerance) { - return Location.OUTSIDE; - } else if (normalizedPoint > lower + tolerance && normalizedPoint < upper - tolerance) { - return Location.INSIDE; - } else { - return (getSize() >= MathUtils.TWO_PI - tolerance) ? Location.INSIDE : Location.BOUNDARY; - } - } - -}
http://git-wip-us.apache.org/repos/asf/commons-math/blob/a7b4803f/src/main/java/org/apache/commons/math3/geometry/spherical/oned/ArcsSet.java ---------------------------------------------------------------------- diff --git a/src/main/java/org/apache/commons/math3/geometry/spherical/oned/ArcsSet.java b/src/main/java/org/apache/commons/math3/geometry/spherical/oned/ArcsSet.java deleted file mode 100644 index 5c03150..0000000 --- a/src/main/java/org/apache/commons/math3/geometry/spherical/oned/ArcsSet.java +++ /dev/null @@ -1,962 +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.oned; - -import java.util.ArrayList; -import java.util.Collection; -import java.util.Iterator; -import java.util.List; -import java.util.NoSuchElementException; - -import org.apache.commons.math3.exception.MathIllegalArgumentException; -import org.apache.commons.math3.exception.MathInternalError; -import org.apache.commons.math3.exception.NumberIsTooLargeException; -import org.apache.commons.math3.exception.util.LocalizedFormats; -import org.apache.commons.math3.geometry.Point; -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.Side; -import org.apache.commons.math3.geometry.partitioning.SubHyperplane; -import org.apache.commons.math3.util.FastMath; -import org.apache.commons.math3.util.MathUtils; -import org.apache.commons.math3.util.Precision; - -/** This class represents a region of a circle: a set of arcs. - * <p> - * Note that due to the wrapping around \(2 \pi\), barycenter is - * ill-defined here. It was defined only in order to fulfill - * the requirements of the {@link - * org.apache.commons.math3.geometry.partitioning.Region Region} - * interface, but its use is discouraged. - * </p> - * @since 3.3 - */ -public class ArcsSet extends AbstractRegion<Sphere1D, Sphere1D> implements Iterable<double[]> { - - /** Build an arcs set representing the whole circle. - * @param tolerance tolerance below which close sub-arcs are merged together - */ - public ArcsSet(final double tolerance) { - super(tolerance); - } - - /** Build an arcs set corresponding to a single arc. - * <p> - * If either {@code lower} is equals to {@code upper} or - * the interval exceeds \( 2 \pi \), the arc is considered - * to be the full circle and its initial defining boundaries - * will be forgotten. {@code lower} is not allowed to be greater - * than {@code upper} (an exception is thrown in this case). - * </p> - * @param lower lower bound of the arc - * @param upper upper bound of the arc - * @param tolerance tolerance below which close sub-arcs are merged together - * @exception NumberIsTooLargeException if lower is greater than upper - */ - public ArcsSet(final double lower, final double upper, final double tolerance) - throws NumberIsTooLargeException { - super(buildTree(lower, upper, tolerance), tolerance); - } - - /** Build an arcs set from an inside/outside 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 arcs set - * @param tolerance tolerance below which close sub-arcs are merged together - * @exception InconsistentStateAt2PiWrapping if the tree leaf nodes are not - * consistent across the \( 0, 2 \pi \) crossing - */ - public ArcsSet(final BSPTree<Sphere1D> tree, final double tolerance) - throws InconsistentStateAt2PiWrapping { - super(tree, tolerance); - check2PiConsistency(); - } - - /** Build an arcs 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 disjoints polyhedrons 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 - * @param tolerance tolerance below which close sub-arcs are merged together - * @exception InconsistentStateAt2PiWrapping if the tree leaf nodes are not - * consistent across the \( 0, 2 \pi \) crossing - */ - public ArcsSet(final Collection<SubHyperplane<Sphere1D>> boundary, final double tolerance) - throws InconsistentStateAt2PiWrapping { - super(boundary, tolerance); - check2PiConsistency(); - } - - /** Build an inside/outside tree representing a single arc. - * @param lower lower angular bound of the arc - * @param upper upper angular bound of the arc - * @param tolerance tolerance below which close sub-arcs are merged together - * @return the built tree - * @exception NumberIsTooLargeException if lower is greater than upper - */ - private static BSPTree<Sphere1D> buildTree(final double lower, final double upper, - final double tolerance) - throws NumberIsTooLargeException { - - if (Precision.equals(lower, upper, 0) || (upper - lower) >= MathUtils.TWO_PI) { - // the tree must cover the whole circle - return new BSPTree<Sphere1D>(Boolean.TRUE); - } else if (lower > upper) { - throw new NumberIsTooLargeException(LocalizedFormats.ENDPOINTS_NOT_AN_INTERVAL, - lower, upper, true); - } - - // this is a regular arc, covering only part of the circle - final double normalizedLower = MathUtils.normalizeAngle(lower, FastMath.PI); - final double normalizedUpper = normalizedLower + (upper - lower); - final SubHyperplane<Sphere1D> lowerCut = - new LimitAngle(new S1Point(normalizedLower), false, tolerance).wholeHyperplane(); - - if (normalizedUpper <= MathUtils.TWO_PI) { - // simple arc starting after 0 and ending before 2 \pi - final SubHyperplane<Sphere1D> upperCut = - new LimitAngle(new S1Point(normalizedUpper), true, tolerance).wholeHyperplane(); - return new BSPTree<Sphere1D>(lowerCut, - new BSPTree<Sphere1D>(Boolean.FALSE), - new BSPTree<Sphere1D>(upperCut, - new BSPTree<Sphere1D>(Boolean.FALSE), - new BSPTree<Sphere1D>(Boolean.TRUE), - null), - null); - } else { - // arc wrapping around 2 \pi - final SubHyperplane<Sphere1D> upperCut = - new LimitAngle(new S1Point(normalizedUpper - MathUtils.TWO_PI), true, tolerance).wholeHyperplane(); - return new BSPTree<Sphere1D>(lowerCut, - new BSPTree<Sphere1D>(upperCut, - new BSPTree<Sphere1D>(Boolean.FALSE), - new BSPTree<Sphere1D>(Boolean.TRUE), - null), - new BSPTree<Sphere1D>(Boolean.TRUE), - null); - } - - } - - /** Check consistency. - * @exception InconsistentStateAt2PiWrapping if the tree leaf nodes are not - * consistent across the \( 0, 2 \pi \) crossing - */ - private void check2PiConsistency() throws InconsistentStateAt2PiWrapping { - - // start search at the tree root - BSPTree<Sphere1D> root = getTree(false); - if (root.getCut() == null) { - return; - } - - // find the inside/outside state before the smallest internal node - final Boolean stateBefore = (Boolean) getFirstLeaf(root).getAttribute(); - - // find the inside/outside state after the largest internal node - final Boolean stateAfter = (Boolean) getLastLeaf(root).getAttribute(); - - if (stateBefore ^ stateAfter) { - throw new InconsistentStateAt2PiWrapping(); - } - - } - - /** Get the first leaf node of a tree. - * @param root tree root - * @return first leaf node (i.e. node corresponding to the region just after 0.0 radians) - */ - private BSPTree<Sphere1D> getFirstLeaf(final BSPTree<Sphere1D> root) { - - if (root.getCut() == null) { - return root; - } - - // find the smallest internal node - BSPTree<Sphere1D> smallest = null; - for (BSPTree<Sphere1D> n = root; n != null; n = previousInternalNode(n)) { - smallest = n; - } - - return leafBefore(smallest); - - } - - /** Get the last leaf node of a tree. - * @param root tree root - * @return last leaf node (i.e. node corresponding to the region just before \( 2 \pi \) radians) - */ - private BSPTree<Sphere1D> getLastLeaf(final BSPTree<Sphere1D> root) { - - if (root.getCut() == null) { - return root; - } - - // find the largest internal node - BSPTree<Sphere1D> largest = null; - for (BSPTree<Sphere1D> n = root; n != null; n = nextInternalNode(n)) { - largest = n; - } - - return leafAfter(largest); - - } - - /** Get the node corresponding to the first arc start. - * @return smallest internal node (i.e. first after 0.0 radians, in trigonometric direction), - * or null if there are no internal nodes (i.e. the set is either empty or covers the full circle) - */ - private BSPTree<Sphere1D> getFirstArcStart() { - - // start search at the tree root - BSPTree<Sphere1D> node = getTree(false); - if (node.getCut() == null) { - return null; - } - - // walk tree until we find the smallest internal node - node = getFirstLeaf(node).getParent(); - - // walk tree until we find an arc start - while (node != null && !isArcStart(node)) { - node = nextInternalNode(node); - } - - return node; - - } - - /** Check if an internal node corresponds to the start angle of an arc. - * @param node internal node to check - * @return true if the node corresponds to the start angle of an arc - */ - private boolean isArcStart(final BSPTree<Sphere1D> node) { - - if ((Boolean) leafBefore(node).getAttribute()) { - // it has an inside cell before it, it may end an arc but not start it - return false; - } - - if (!(Boolean) leafAfter(node).getAttribute()) { - // it has an outside cell after it, it is a dummy cut away from real arcs - return false; - } - - // the cell has an outside before and an inside after it - // it is the start of an arc - return true; - - } - - /** Check if an internal node corresponds to the end angle of an arc. - * @param node internal node to check - * @return true if the node corresponds to the end angle of an arc - */ - private boolean isArcEnd(final BSPTree<Sphere1D> node) { - - if (!(Boolean) leafBefore(node).getAttribute()) { - // it has an outside cell before it, it may start an arc but not end it - return false; - } - - if ((Boolean) leafAfter(node).getAttribute()) { - // it has an inside cell after it, it is a dummy cut in the middle of an arc - return false; - } - - // the cell has an inside before and an outside after it - // it is the end of an arc - return true; - - } - - /** Get the next internal node. - * @param node current internal node - * @return next internal node in trigonometric order, or null - * if this is the last internal node - */ - private BSPTree<Sphere1D> nextInternalNode(BSPTree<Sphere1D> node) { - - if (childAfter(node).getCut() != null) { - // the next node is in the sub-tree - return leafAfter(node).getParent(); - } - - // there is nothing left deeper in the tree, we backtrack - while (isAfterParent(node)) { - node = node.getParent(); - } - return node.getParent(); - - } - - /** Get the previous internal node. - * @param node current internal node - * @return previous internal node in trigonometric order, or null - * if this is the first internal node - */ - private BSPTree<Sphere1D> previousInternalNode(BSPTree<Sphere1D> node) { - - if (childBefore(node).getCut() != null) { - // the next node is in the sub-tree - return leafBefore(node).getParent(); - } - - // there is nothing left deeper in the tree, we backtrack - while (isBeforeParent(node)) { - node = node.getParent(); - } - return node.getParent(); - - } - - /** Find the leaf node just before an internal node. - * @param node internal node at which the sub-tree starts - * @return leaf node just before the internal node - */ - private BSPTree<Sphere1D> leafBefore(BSPTree<Sphere1D> node) { - - node = childBefore(node); - while (node.getCut() != null) { - node = childAfter(node); - } - - return node; - - } - - /** Find the leaf node just after an internal node. - * @param node internal node at which the sub-tree starts - * @return leaf node just after the internal node - */ - private BSPTree<Sphere1D> leafAfter(BSPTree<Sphere1D> node) { - - node = childAfter(node); - while (node.getCut() != null) { - node = childBefore(node); - } - - return node; - - } - - /** Check if a node is the child before its parent in trigonometric order. - * @param node child node considered - * @return true is the node has a parent end is before it in trigonometric order - */ - private boolean isBeforeParent(final BSPTree<Sphere1D> node) { - final BSPTree<Sphere1D> parent = node.getParent(); - if (parent == null) { - return false; - } else { - return node == childBefore(parent); - } - } - - /** Check if a node is the child after its parent in trigonometric order. - * @param node child node considered - * @return true is the node has a parent end is after it in trigonometric order - */ - private boolean isAfterParent(final BSPTree<Sphere1D> node) { - final BSPTree<Sphere1D> parent = node.getParent(); - if (parent == null) { - return false; - } else { - return node == childAfter(parent); - } - } - - /** Find the child node just before an internal node. - * @param node internal node at which the sub-tree starts - * @return child node just before the internal node - */ - private BSPTree<Sphere1D> childBefore(BSPTree<Sphere1D> node) { - if (isDirect(node)) { - // smaller angles are on minus side, larger angles are on plus side - return node.getMinus(); - } else { - // smaller angles are on plus side, larger angles are on minus side - return node.getPlus(); - } - } - - /** Find the child node just after an internal node. - * @param node internal node at which the sub-tree starts - * @return child node just after the internal node - */ - private BSPTree<Sphere1D> childAfter(BSPTree<Sphere1D> node) { - if (isDirect(node)) { - // smaller angles are on minus side, larger angles are on plus side - return node.getPlus(); - } else { - // smaller angles are on plus side, larger angles are on minus side - return node.getMinus(); - } - } - - /** Check if an internal node has a direct limit angle. - * @param node internal node to check - * @return true if the limit angle is direct - */ - private boolean isDirect(final BSPTree<Sphere1D> node) { - return ((LimitAngle) node.getCut().getHyperplane()).isDirect(); - } - - /** Get the limit angle of an internal node. - * @param node internal node to check - * @return limit angle - */ - private double getAngle(final BSPTree<Sphere1D> node) { - return ((LimitAngle) node.getCut().getHyperplane()).getLocation().getAlpha(); - } - - /** {@inheritDoc} */ - @Override - public ArcsSet buildNew(final BSPTree<Sphere1D> tree) { - return new ArcsSet(tree, getTolerance()); - } - - /** {@inheritDoc} */ - @Override - protected void computeGeometricalProperties() { - if (getTree(false).getCut() == null) { - setBarycenter(S1Point.NaN); - setSize(((Boolean) getTree(false).getAttribute()) ? MathUtils.TWO_PI : 0); - } else { - double size = 0.0; - double sum = 0.0; - for (final double[] a : this) { - final double length = a[1] - a[0]; - size += length; - sum += length * (a[0] + a[1]); - } - setSize(size); - if (Precision.equals(size, MathUtils.TWO_PI, 0)) { - setBarycenter(S1Point.NaN); - } else if (size >= Precision.SAFE_MIN) { - setBarycenter(new S1Point(sum / (2 * size))); - } else { - final LimitAngle limit = (LimitAngle) getTree(false).getCut().getHyperplane(); - setBarycenter(limit.getLocation()); - } - } - } - - /** {@inheritDoc} - * @since 3.3 - */ - @Override - public BoundaryProjection<Sphere1D> projectToBoundary(final Point<Sphere1D> point) { - - // get position of test point - final double alpha = ((S1Point) point).getAlpha(); - - boolean wrapFirst = false; - double first = Double.NaN; - double previous = Double.NaN; - for (final double[] a : this) { - - if (Double.isNaN(first)) { - // remember the first angle in case we need it later - first = a[0]; - } - - if (!wrapFirst) { - if (alpha < a[0]) { - // the test point lies between the previous and the current arcs - // offset will be positive - if (Double.isNaN(previous)) { - // we need to wrap around the circle - wrapFirst = true; - } else { - final double previousOffset = alpha - previous; - final double currentOffset = a[0] - alpha; - if (previousOffset < currentOffset) { - return new BoundaryProjection<Sphere1D>(point, new S1Point(previous), previousOffset); - } else { - return new BoundaryProjection<Sphere1D>(point, new S1Point(a[0]), currentOffset); - } - } - } else if (alpha <= a[1]) { - // the test point lies within the current arc - // offset will be negative - final double offset0 = a[0] - alpha; - final double offset1 = alpha - a[1]; - if (offset0 < offset1) { - return new BoundaryProjection<Sphere1D>(point, new S1Point(a[1]), offset1); - } else { - return new BoundaryProjection<Sphere1D>(point, new S1Point(a[0]), offset0); - } - } - } - previous = a[1]; - } - - if (Double.isNaN(previous)) { - - // there are no points at all in the arcs set - return new BoundaryProjection<Sphere1D>(point, null, MathUtils.TWO_PI); - - } else { - - // the test point if before first arc and after last arc, - // somewhere around the 0/2 \pi crossing - if (wrapFirst) { - // the test point is between 0 and first - final double previousOffset = alpha - (previous - MathUtils.TWO_PI); - final double currentOffset = first - alpha; - if (previousOffset < currentOffset) { - return new BoundaryProjection<Sphere1D>(point, new S1Point(previous), previousOffset); - } else { - return new BoundaryProjection<Sphere1D>(point, new S1Point(first), currentOffset); - } - } else { - // the test point is between last and 2\pi - final double previousOffset = alpha - previous; - final double currentOffset = first + MathUtils.TWO_PI - alpha; - if (previousOffset < currentOffset) { - return new BoundaryProjection<Sphere1D>(point, new S1Point(previous), previousOffset); - } else { - return new BoundaryProjection<Sphere1D>(point, new S1Point(first), currentOffset); - } - } - - } - - } - - /** Build an ordered list of arcs representing the instance. - * <p>This method builds this arcs set as an ordered list of - * {@link Arc Arc} elements. An empty tree will build an empty list - * while a tree representing the whole circle will build a one - * element list with bounds set to \( 0 and 2 \pi \).</p> - * @return a new ordered list containing {@link Arc Arc} elements - */ - public List<Arc> asList() { - final List<Arc> list = new ArrayList<Arc>(); - for (final double[] a : this) { - list.add(new Arc(a[0], a[1], getTolerance())); - } - return list; - } - - /** {@inheritDoc} - * <p> - * The iterator returns the limit angles pairs of sub-arcs in trigonometric order. - * </p> - * <p> - * The iterator does <em>not</em> support the optional {@code remove} operation. - * </p> - */ - public Iterator<double[]> iterator() { - return new SubArcsIterator(); - } - - /** Local iterator for sub-arcs. */ - private class SubArcsIterator implements Iterator<double[]> { - - /** Start of the first arc. */ - private final BSPTree<Sphere1D> firstStart; - - /** Current node. */ - private BSPTree<Sphere1D> current; - - /** Sub-arc no yet returned. */ - private double[] pending; - - /** Simple constructor. - */ - public SubArcsIterator() { - - firstStart = getFirstArcStart(); - current = firstStart; - - if (firstStart == null) { - // all the leaf tree nodes share the same inside/outside status - if ((Boolean) getFirstLeaf(getTree(false)).getAttribute()) { - // it is an inside node, it represents the full circle - pending = new double[] { - 0, MathUtils.TWO_PI - }; - } else { - pending = null; - } - } else { - selectPending(); - } - } - - /** Walk the tree to select the pending sub-arc. - */ - private void selectPending() { - - // look for the start of the arc - BSPTree<Sphere1D> start = current; - while (start != null && !isArcStart(start)) { - start = nextInternalNode(start); - } - - if (start == null) { - // we have exhausted the iterator - current = null; - pending = null; - return; - } - - // look for the end of the arc - BSPTree<Sphere1D> end = start; - while (end != null && !isArcEnd(end)) { - end = nextInternalNode(end); - } - - if (end != null) { - - // we have identified the arc - pending = new double[] { - getAngle(start), getAngle(end) - }; - - // prepare search for next arc - current = end; - - } else { - - // the final arc wraps around 2\pi, its end is before the first start - end = firstStart; - while (end != null && !isArcEnd(end)) { - end = previousInternalNode(end); - } - if (end == null) { - // this should never happen - throw new MathInternalError(); - } - - // we have identified the last arc - pending = new double[] { - getAngle(start), getAngle(end) + MathUtils.TWO_PI - }; - - // there won't be any other arcs - current = null; - - } - - } - - /** {@inheritDoc} */ - public boolean hasNext() { - return pending != null; - } - - /** {@inheritDoc} */ - public double[] next() { - if (pending == null) { - throw new NoSuchElementException(); - } - final double[] next = pending; - selectPending(); - return next; - } - - /** {@inheritDoc} */ - public void remove() { - throw new UnsupportedOperationException(); - } - - } - - /** Compute the relative position of the instance with respect - * to an arc. - * <p> - * The {@link Side#MINUS} side of the arc is the one covered by the arc. - * </p> - * @param arc arc to check instance against - * @return one of {@link Side#PLUS}, {@link Side#MINUS}, {@link Side#BOTH} - * or {@link Side#HYPER} - */ - public Side side(final Arc arc) { - - final double reference = FastMath.PI + arc.getInf(); - final double arcLength = arc.getSup() - arc.getInf(); - - boolean inMinus = false; - boolean inPlus = false; - for (final double[] a : this) { - final double syncedStart = MathUtils.normalizeAngle(a[0], reference) - arc.getInf(); - final double arcOffset = a[0] - syncedStart; - final double syncedEnd = a[1] - arcOffset; - if (syncedStart <= arcLength - getTolerance() || syncedEnd >= MathUtils.TWO_PI + getTolerance()) { - inMinus = true; - } - if (syncedEnd >= arcLength + getTolerance()) { - inPlus = true; - } - } - - if (inMinus) { - if (inPlus) { - return Side.BOTH; - } else { - return Side.MINUS; - } - } else { - if (inPlus) { - return Side.PLUS; - } else { - return Side.HYPER; - } - } - - } - - /** Split the instance in two parts by an arc. - * @param arc splitting arc - * @return an object containing both the part of the instance - * on the plus side of the arc and the part of the - * instance on the minus side of the arc - */ - public Split split(final Arc arc) { - - final List<Double> minus = new ArrayList<Double>(); - final List<Double> plus = new ArrayList<Double>(); - - final double reference = FastMath.PI + arc.getInf(); - final double arcLength = arc.getSup() - arc.getInf(); - - for (final double[] a : this) { - final double syncedStart = MathUtils.normalizeAngle(a[0], reference) - arc.getInf(); - final double arcOffset = a[0] - syncedStart; - final double syncedEnd = a[1] - arcOffset; - if (syncedStart < arcLength) { - // the start point a[0] is in the minus part of the arc - minus.add(a[0]); - if (syncedEnd > arcLength) { - // the end point a[1] is past the end of the arc - // so we leave the minus part and enter the plus part - final double minusToPlus = arcLength + arcOffset; - minus.add(minusToPlus); - plus.add(minusToPlus); - if (syncedEnd > MathUtils.TWO_PI) { - // in fact the end point a[1] goes far enough that we - // leave the plus part of the arc and enter the minus part again - final double plusToMinus = MathUtils.TWO_PI + arcOffset; - plus.add(plusToMinus); - minus.add(plusToMinus); - minus.add(a[1]); - } else { - // the end point a[1] is in the plus part of the arc - plus.add(a[1]); - } - } else { - // the end point a[1] is in the minus part of the arc - minus.add(a[1]); - } - } else { - // the start point a[0] is in the plus part of the arc - plus.add(a[0]); - if (syncedEnd > MathUtils.TWO_PI) { - // the end point a[1] wraps around to the start of the arc - // so we leave the plus part and enter the minus part - final double plusToMinus = MathUtils.TWO_PI + arcOffset; - plus.add(plusToMinus); - minus.add(plusToMinus); - if (syncedEnd > MathUtils.TWO_PI + arcLength) { - // in fact the end point a[1] goes far enough that we - // leave the minus part of the arc and enter the plus part again - final double minusToPlus = MathUtils.TWO_PI + arcLength + arcOffset; - minus.add(minusToPlus); - plus.add(minusToPlus); - plus.add(a[1]); - } else { - // the end point a[1] is in the minus part of the arc - minus.add(a[1]); - } - } else { - // the end point a[1] is in the plus part of the arc - plus.add(a[1]); - } - } - } - - return new Split(createSplitPart(plus), createSplitPart(minus)); - - } - - /** Add an arc limit to a BSP tree under construction. - * @param tree BSP tree under construction - * @param alpha arc limit - * @param isStart if true, the limit is the start of an arc - */ - private void addArcLimit(final BSPTree<Sphere1D> tree, final double alpha, final boolean isStart) { - - final LimitAngle limit = new LimitAngle(new S1Point(alpha), !isStart, getTolerance()); - final BSPTree<Sphere1D> node = tree.getCell(limit.getLocation(), getTolerance()); - if (node.getCut() != null) { - // this should never happen - throw new MathInternalError(); - } - - node.insertCut(limit); - node.setAttribute(null); - node.getPlus().setAttribute(Boolean.FALSE); - node.getMinus().setAttribute(Boolean.TRUE); - - } - - /** Create a split part. - * <p> - * As per construction, the list of limit angles is known to have - * an even number of entries, with start angles at even indices and - * end angles at odd indices. - * </p> - * @param limits limit angles of the split part - * @return split part (may be null) - */ - private ArcsSet createSplitPart(final List<Double> limits) { - if (limits.isEmpty()) { - return null; - } else { - - // collapse close limit angles - for (int i = 0; i < limits.size(); ++i) { - final int j = (i + 1) % limits.size(); - final double lA = limits.get(i); - final double lB = MathUtils.normalizeAngle(limits.get(j), lA); - if (FastMath.abs(lB - lA) <= getTolerance()) { - // the two limits are too close to each other, we remove both of them - if (j > 0) { - // regular case, the two entries are consecutive ones - limits.remove(j); - limits.remove(i); - i = i - 1; - } else { - // special case, i the the last entry and j is the first entry - // we have wrapped around list end - final double lEnd = limits.remove(limits.size() - 1); - final double lStart = limits.remove(0); - if (limits.isEmpty()) { - // the ends were the only limits, is it a full circle or an empty circle? - if (lEnd - lStart > FastMath.PI) { - // it was full circle - return new ArcsSet(new BSPTree<Sphere1D>(Boolean.TRUE), getTolerance()); - } else { - // it was an empty circle - return null; - } - } else { - // we have removed the first interval start, so our list - // currently starts with an interval end, which is wrong - // we need to move this interval end to the end of the list - limits.add(limits.remove(0) + MathUtils.TWO_PI); - } - } - } - } - - // build the tree by adding all angular sectors - BSPTree<Sphere1D> tree = new BSPTree<Sphere1D>(Boolean.FALSE); - for (int i = 0; i < limits.size() - 1; i += 2) { - addArcLimit(tree, limits.get(i), true); - addArcLimit(tree, limits.get(i + 1), false); - } - - if (tree.getCut() == null) { - // we did not insert anything - return null; - } - - return new ArcsSet(tree, getTolerance()); - - } - } - - /** Class holding the results of the {@link #split split} method. - */ - public static class Split { - - /** Part of the arcs set on the plus side of the splitting arc. */ - private final ArcsSet plus; - - /** Part of the arcs set on the minus side of the splitting arc. */ - private final ArcsSet minus; - - /** Build a Split from its parts. - * @param plus part of the arcs set on the plus side of the - * splitting arc - * @param minus part of the arcs set on the minus side of the - * splitting arc - */ - private Split(final ArcsSet plus, final ArcsSet minus) { - this.plus = plus; - this.minus = minus; - } - - /** Get the part of the arcs set on the plus side of the splitting arc. - * @return part of the arcs set on the plus side of the splitting arc - */ - public ArcsSet getPlus() { - return plus; - } - - /** Get the part of the arcs set on the minus side of the splitting arc. - * @return part of the arcs set on the minus side of the splitting arc - */ - public ArcsSet getMinus() { - return minus; - } - - } - - /** Specialized exception for inconsistent BSP tree state inconsistency. - * <p> - * This exception is thrown at {@link ArcsSet} construction time when the - * {@link org.apache.commons.math3.geometry.partitioning.Region.Location inside/outside} - * state is not consistent at the 0, \(2 \pi \) crossing. - * </p> - */ - public static class InconsistentStateAt2PiWrapping extends MathIllegalArgumentException { - - /** Serializable UID. */ - private static final long serialVersionUID = 20140107L; - - /** Simple constructor. - */ - public InconsistentStateAt2PiWrapping() { - super(LocalizedFormats.INCONSISTENT_STATE_AT_2_PI_WRAPPING); - } - - } - -} http://git-wip-us.apache.org/repos/asf/commons-math/blob/a7b4803f/src/main/java/org/apache/commons/math3/geometry/spherical/oned/LimitAngle.java ---------------------------------------------------------------------- diff --git a/src/main/java/org/apache/commons/math3/geometry/spherical/oned/LimitAngle.java b/src/main/java/org/apache/commons/math3/geometry/spherical/oned/LimitAngle.java deleted file mode 100644 index 748a142..0000000 --- a/src/main/java/org/apache/commons/math3/geometry/spherical/oned/LimitAngle.java +++ /dev/null @@ -1,127 +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.oned; - -import org.apache.commons.math3.geometry.Point; -import org.apache.commons.math3.geometry.partitioning.Hyperplane; - -/** This class represents a 1D oriented hyperplane on the circle. - * <p>An hyperplane on the 1-sphere is an angle with an orientation.</p> - * <p>Instances of this class are guaranteed to be immutable.</p> - * @since 3.3 - */ -public class LimitAngle implements Hyperplane<Sphere1D> { - - /** Angle location. */ - private S1Point location; - - /** Orientation. */ - private boolean direct; - - /** Tolerance below which angles are considered identical. */ - private final double tolerance; - - /** Simple constructor. - * @param location location of the hyperplane - * @param direct if true, the plus side of the hyperplane is towards - * angles greater than {@code location} - * @param tolerance tolerance below which angles are considered identical - */ - public LimitAngle(final S1Point location, final boolean direct, final double tolerance) { - this.location = location; - this.direct = direct; - this.tolerance = tolerance; - } - - /** Copy the instance. - * <p>Since instances are immutable, this method directly returns - * the instance.</p> - * @return the instance itself - */ - public LimitAngle copySelf() { - return this; - } - - /** {@inheritDoc} */ - public double getOffset(final Point<Sphere1D> point) { - final double delta = ((S1Point) point).getAlpha() - location.getAlpha(); - return direct ? delta : -delta; - } - - /** Check if the hyperplane orientation is direct. - * @return true if the plus side of the hyperplane is towards - * angles greater than hyperplane location - */ - public boolean isDirect() { - return direct; - } - - /** Get the reverse of the instance. - * <p>Get a limit angle with reversed orientation with respect to the - * instance. A new object is built, the instance is untouched.</p> - * @return a new limit angle, with orientation opposite to the instance orientation - */ - public LimitAngle getReverse() { - return new LimitAngle(location, !direct, tolerance); - } - - /** Build a region covering the whole hyperplane. - * <p>Since this class represent zero dimension spaces which does - * not have lower dimension sub-spaces, this method returns a dummy - * implementation of a {@link - * org.apache.commons.math3.geometry.partitioning.SubHyperplane SubHyperplane}. - * This implementation is only used to allow the {@link - * org.apache.commons.math3.geometry.partitioning.SubHyperplane - * SubHyperplane} class implementation to work properly, it should - * <em>not</em> be used otherwise.</p> - * @return a dummy sub hyperplane - */ - public SubLimitAngle wholeHyperplane() { - return new SubLimitAngle(this, null); - } - - /** Build a region covering the whole space. - * @return a region containing the instance (really an {@link - * ArcsSet IntervalsSet} instance) - */ - public ArcsSet wholeSpace() { - return new ArcsSet(tolerance); - } - - /** {@inheritDoc} */ - public boolean sameOrientationAs(final Hyperplane<Sphere1D> other) { - return !(direct ^ ((LimitAngle) other).direct); - } - - /** Get the hyperplane location on the circle. - * @return the hyperplane location - */ - public S1Point getLocation() { - return location; - } - - /** {@inheritDoc} */ - public Point<Sphere1D> project(Point<Sphere1D> point) { - return location; - } - - /** {@inheritDoc} */ - public double getTolerance() { - return tolerance; - } - -} http://git-wip-us.apache.org/repos/asf/commons-math/blob/a7b4803f/src/main/java/org/apache/commons/math3/geometry/spherical/oned/S1Point.java ---------------------------------------------------------------------- diff --git a/src/main/java/org/apache/commons/math3/geometry/spherical/oned/S1Point.java b/src/main/java/org/apache/commons/math3/geometry/spherical/oned/S1Point.java deleted file mode 100644 index 263a559..0000000 --- a/src/main/java/org/apache/commons/math3/geometry/spherical/oned/S1Point.java +++ /dev/null @@ -1,157 +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.oned; - -import org.apache.commons.math3.geometry.Point; -import org.apache.commons.math3.geometry.Space; -import org.apache.commons.math3.geometry.euclidean.twod.Vector2D; -import org.apache.commons.math3.util.FastMath; -import org.apache.commons.math3.util.MathUtils; - -/** This class represents a point on the 1-sphere. - * <p>Instances of this class are guaranteed to be immutable.</p> - * @since 3.3 - */ -public class S1Point implements Point<Sphere1D> { - - // CHECKSTYLE: stop ConstantName - /** A vector with all coordinates set to NaN. */ - public static final S1Point NaN = new S1Point(Double.NaN, Vector2D.NaN); - // CHECKSTYLE: resume ConstantName - - /** Serializable UID. */ - private static final long serialVersionUID = 20131218L; - - /** Azimuthal angle \( \alpha \). */ - private final double alpha; - - /** Corresponding 2D normalized vector. */ - private final Vector2D vector; - - /** Simple constructor. - * Build a vector from its coordinates - * @param alpha azimuthal angle \( \alpha \) - * @see #getAlpha() - */ - public S1Point(final double alpha) { - this(MathUtils.normalizeAngle(alpha, FastMath.PI), - new Vector2D(FastMath.cos(alpha), FastMath.sin(alpha))); - } - - /** Build a point from its internal components. - * @param alpha azimuthal angle \( \alpha \) - * @param vector corresponding vector - */ - private S1Point(final double alpha, final Vector2D vector) { - this.alpha = alpha; - this.vector = vector; - } - - /** Get the azimuthal angle \( \alpha \). - * @return azimuthal angle \( \alpha \) - * @see #S1Point(double) - */ - public double getAlpha() { - return alpha; - } - - /** Get the corresponding normalized vector in the 2D euclidean space. - * @return normalized vector - */ - public Vector2D getVector() { - return vector; - } - - /** {@inheritDoc} */ - public Space getSpace() { - return Sphere1D.getInstance(); - } - - /** {@inheritDoc} */ - public boolean isNaN() { - return Double.isNaN(alpha); - } - - /** {@inheritDoc} */ - public double distance(final Point<Sphere1D> point) { - return distance(this, (S1Point) 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(S1Point p1, S1Point p2) { - return Vector2D.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 S1Point) { - final S1Point rhs = (S1Point) other; - if (rhs.isNaN()) { - return this.isNaN(); - } - - return alpha == rhs.alpha; - } - - 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 1759 * MathUtils.hash(alpha); - } - -} http://git-wip-us.apache.org/repos/asf/commons-math/blob/a7b4803f/src/main/java/org/apache/commons/math3/geometry/spherical/oned/Sphere1D.java ---------------------------------------------------------------------- diff --git a/src/main/java/org/apache/commons/math3/geometry/spherical/oned/Sphere1D.java b/src/main/java/org/apache/commons/math3/geometry/spherical/oned/Sphere1D.java deleted file mode 100644 index ce5c7cd..0000000 --- a/src/main/java/org/apache/commons/math3/geometry/spherical/oned/Sphere1D.java +++ /dev/null @@ -1,106 +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.oned; - -import java.io.Serializable; - -import org.apache.commons.math3.exception.MathUnsupportedOperationException; -import org.apache.commons.math3.exception.util.LocalizedFormats; -import org.apache.commons.math3.geometry.Space; - -/** - * This class implements a one-dimensional sphere (i.e. a circle). - * <p> - * We use here the topologists definition of the 1-sphere (see - * <a href="http://mathworld.wolfram.com/Sphere.html";>Sphere</a> on - * MathWorld), i.e. the 1-sphere is the one-dimensional closed curve - * defined in 2D as x<sup>2</sup>+y<sup>2</sup>=1. - * </p> - * @since 3.3 - */ -public class Sphere1D implements Serializable, Space { - - /** Serializable version identifier. */ - private static final long serialVersionUID = 20131218L; - - /** Private constructor for the singleton. - */ - private Sphere1D() { - } - - /** Get the unique instance. - * @return the unique instance - */ - public static Sphere1D getInstance() { - return LazyHolder.INSTANCE; - } - - /** {@inheritDoc} */ - public int getDimension() { - return 1; - } - - /** {@inheritDoc} - * <p> - * As the 1-dimension sphere does not have proper sub-spaces, - * this method always throws a {@link NoSubSpaceException} - * </p> - * @return nothing - * @throws NoSubSpaceException in all cases - */ - public Space getSubSpace() throws NoSubSpaceException { - throw new NoSubSpaceException(); - } - - // 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 Sphere1D INSTANCE = new Sphere1D(); - } - // CHECKSTYLE: resume HideUtilityClassConstructor - - /** Handle deserialization of the singleton. - * @return the singleton instance - */ - private Object readResolve() { - // return the singleton instance - return LazyHolder.INSTANCE; - } - - /** Specialized exception for inexistent sub-space. - * <p> - * This exception is thrown when attempting to get the sub-space of a one-dimensional space - * </p> - */ - public static class NoSubSpaceException extends MathUnsupportedOperationException { - - /** Serializable UID. */ - private static final long serialVersionUID = 20140225L; - - /** Simple constructor. - */ - public NoSubSpaceException() { - super(LocalizedFormats.NOT_SUPPORTED_IN_DIMENSION_N, 1); - } - - } - -} http://git-wip-us.apache.org/repos/asf/commons-math/blob/a7b4803f/src/main/java/org/apache/commons/math3/geometry/spherical/oned/SubLimitAngle.java ---------------------------------------------------------------------- diff --git a/src/main/java/org/apache/commons/math3/geometry/spherical/oned/SubLimitAngle.java b/src/main/java/org/apache/commons/math3/geometry/spherical/oned/SubLimitAngle.java deleted file mode 100644 index 880a7e8..0000000 --- a/src/main/java/org/apache/commons/math3/geometry/spherical/oned/SubLimitAngle.java +++ /dev/null @@ -1,74 +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.oned; - -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; - -/** This class represents sub-hyperplane for {@link LimitAngle}. - * <p>Instances of this class are guaranteed to be immutable.</p> - * @since 3.3 - */ -public class SubLimitAngle extends AbstractSubHyperplane<Sphere1D, Sphere1D> { - - /** Simple constructor. - * @param hyperplane underlying hyperplane - * @param remainingRegion remaining region of the hyperplane - */ - public SubLimitAngle(final Hyperplane<Sphere1D> hyperplane, - final Region<Sphere1D> remainingRegion) { - super(hyperplane, remainingRegion); - } - - /** {@inheritDoc} */ - @Override - public double getSize() { - return 0; - } - - /** {@inheritDoc} */ - @Override - public boolean isEmpty() { - return false; - } - - /** {@inheritDoc} */ - @Override - protected AbstractSubHyperplane<Sphere1D, Sphere1D> buildNew(final Hyperplane<Sphere1D> hyperplane, - final Region<Sphere1D> remainingRegion) { - return new SubLimitAngle(hyperplane, remainingRegion); - } - - /** {@inheritDoc} */ - @Override - public Side side(final Hyperplane<Sphere1D> hyperplane) { - final double global = hyperplane.getOffset(((LimitAngle) getHyperplane()).getLocation()); - return (global < -1.0e-10) ? Side.MINUS : ((global > 1.0e-10) ? Side.PLUS : Side.HYPER); - } - - /** {@inheritDoc} */ - @Override - public SplitSubHyperplane<Sphere1D> split(final Hyperplane<Sphere1D> hyperplane) { - final double global = hyperplane.getOffset(((LimitAngle) getHyperplane()).getLocation()); - return (global < -1.0e-10) ? - new SplitSubHyperplane<Sphere1D>(null, this) : - new SplitSubHyperplane<Sphere1D>(this, null); - } - -} http://git-wip-us.apache.org/repos/asf/commons-math/blob/a7b4803f/src/main/java/org/apache/commons/math3/geometry/spherical/oned/package-info.java ---------------------------------------------------------------------- diff --git a/src/main/java/org/apache/commons/math3/geometry/spherical/oned/package-info.java b/src/main/java/org/apache/commons/math3/geometry/spherical/oned/package-info.java deleted file mode 100644 index d54bc0b..0000000 --- a/src/main/java/org/apache/commons/math3/geometry/spherical/oned/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 1-sphere. - * </p> - * <p> - * We use here the topologists definition of the 1-sphere (see - * <a href="http://mathworld.wolfram.com/Sphere.html";>Sphere</a> on - * MathWorld), i.e. the 1-sphere is the one-dimensional closed curve - * defined in 2D as x<sup>2</sup>+y<sup>2</sup>=1. - * </p> - * - */ -package org.apache.commons.math3.geometry.spherical.oned; http://git-wip-us.apache.org/repos/asf/commons-math/blob/a7b4803f/src/main/java/org/apache/commons/math3/geometry/spherical/twod/Circle.java ---------------------------------------------------------------------- diff --git a/src/main/java/org/apache/commons/math3/geometry/spherical/twod/Circle.java b/src/main/java/org/apache/commons/math3/geometry/spherical/twod/Circle.java deleted file mode 100644 index d6d47de..0000000 --- a/src/main/java/org/apache/commons/math3/geometry/spherical/twod/Circle.java +++ /dev/null @@ -1,326 +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.Point; -import org.apache.commons.math3.geometry.euclidean.threed.Rotation; -import org.apache.commons.math3.geometry.euclidean.threed.Vector3D; -import org.apache.commons.math3.geometry.partitioning.Embedding; -import org.apache.commons.math3.geometry.partitioning.Hyperplane; -import org.apache.commons.math3.geometry.partitioning.SubHyperplane; -import org.apache.commons.math3.geometry.partitioning.Transform; -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; -import org.apache.commons.math3.geometry.spherical.oned.Sphere1D; -import org.apache.commons.math3.util.FastMath; - -/** This class represents an oriented great circle on the 2-sphere. - - * <p>An oriented circle can be defined by a center point. The circle - * is the the set of points that are in the normal plan the center.</p> - - * <p>Since it is oriented the two spherical caps at its two sides are - * unambiguously identified as a left cap and a right cap. This can be - * used to identify the interior and the exterior in a simple way by - * local properties only when part of a line is used to define part of - * a spherical polygon boundary.</p> - - * @since 3.3 - */ -public class Circle implements Hyperplane<Sphere2D>, Embedding<Sphere2D, Sphere1D> { - - /** Pole or circle center. */ - private Vector3D pole; - - /** First axis in the equator plane, origin of the phase angles. */ - private Vector3D x; - - /** Second axis in the equator plane, in quadrature with respect to x. */ - private Vector3D y; - - /** Tolerance below which close sub-arcs are merged together. */ - private final double tolerance; - - /** Build a great circle from its pole. - * <p>The circle is oriented in the trigonometric direction around pole.</p> - * @param pole circle pole - * @param tolerance tolerance below which close sub-arcs are merged together - */ - public Circle(final Vector3D pole, final double tolerance) { - reset(pole); - this.tolerance = tolerance; - } - - /** Build a great circle from two non-aligned points. - * <p>The circle is oriented from first to second point using the path smaller than \( \pi \).</p> - * @param first first point contained in the great circle - * @param second second point contained in the great circle - * @param tolerance tolerance below which close sub-arcs are merged together - */ - public Circle(final S2Point first, final S2Point second, final double tolerance) { - reset(first.getVector().crossProduct(second.getVector())); - this.tolerance = tolerance; - } - - /** Build a circle from its internal components. - * <p>The circle is oriented in the trigonometric direction around center.</p> - * @param pole circle pole - * @param x first axis in the equator plane - * @param y second axis in the equator plane - * @param tolerance tolerance below which close sub-arcs are merged together - */ - private Circle(final Vector3D pole, final Vector3D x, final Vector3D y, - final double tolerance) { - this.pole = pole; - this.x = x; - this.y = y; - this.tolerance = tolerance; - } - - /** Copy constructor. - * <p>The created instance is completely independent from the - * original instance, it is a deep copy.</p> - * @param circle circle to copy - */ - public Circle(final Circle circle) { - this(circle.pole, circle.x, circle.y, circle.tolerance); - } - - /** {@inheritDoc} */ - public Circle copySelf() { - return new Circle(this); - } - - /** Reset the instance as if built from a pole. - * <p>The circle is oriented in the trigonometric direction around pole.</p> - * @param newPole circle pole - */ - public void reset(final Vector3D newPole) { - this.pole = newPole.normalize(); - this.x = newPole.orthogonal(); - this.y = Vector3D.crossProduct(newPole, x).normalize(); - } - - /** Revert the instance. - */ - public void revertSelf() { - // x remains the same - y = y.negate(); - pole = pole.negate(); - } - - /** Get the reverse of the instance. - * <p>Get a circle with reversed orientation with respect to the - * instance. A new object is built, the instance is untouched.</p> - * @return a new circle, with orientation opposite to the instance orientation - */ - public Circle getReverse() { - return new Circle(pole.negate(), x, y.negate(), tolerance); - } - - /** {@inheritDoc} */ - public Point<Sphere2D> project(Point<Sphere2D> point) { - return toSpace(toSubSpace(point)); - } - - /** {@inheritDoc} */ - public double getTolerance() { - return tolerance; - } - - /** {@inheritDoc} - * @see #getPhase(Vector3D) - */ - public S1Point toSubSpace(final Point<Sphere2D> point) { - return new S1Point(getPhase(((S2Point) point).getVector())); - } - - /** Get the phase angle of a direction. - * <p> - * The direction may not belong to the circle as the - * phase is computed for the meridian plane between the circle - * pole and the direction. - * </p> - * @param direction direction for which phase is requested - * @return phase angle of the direction around the circle - * @see #toSubSpace(Point) - */ - public double getPhase(final Vector3D direction) { - return FastMath.PI + FastMath.atan2(-direction.dotProduct(y), -direction.dotProduct(x)); - } - - /** {@inheritDoc} - * @see #getPointAt(double) - */ - public S2Point toSpace(final Point<Sphere1D> point) { - return new S2Point(getPointAt(((S1Point) point).getAlpha())); - } - - /** Get a circle point from its phase around the circle. - * @param alpha phase around the circle - * @return circle point on the sphere - * @see #toSpace(Point) - * @see #getXAxis() - * @see #getYAxis() - */ - public Vector3D getPointAt(final double alpha) { - return new Vector3D(FastMath.cos(alpha), x, FastMath.sin(alpha), y); - } - - /** Get the X axis of the circle. - * <p> - * This method returns the same value as {@link #getPointAt(double) - * getPointAt(0.0)} but it does not do any computation and always - * return the same instance. - * </p> - * @return an arbitrary x axis on the circle - * @see #getPointAt(double) - * @see #getYAxis() - * @see #getPole() - */ - public Vector3D getXAxis() { - return x; - } - - /** Get the Y axis of the circle. - * <p> - * This method returns the same value as {@link #getPointAt(double) - * getPointAt(0.5 * FastMath.PI)} but it does not do any computation and always - * return the same instance. - * </p> - * @return an arbitrary y axis point on the circle - * @see #getPointAt(double) - * @see #getXAxis() - * @see #getPole() - */ - public Vector3D getYAxis() { - return y; - } - - /** Get the pole of the circle. - * <p> - * As the circle is a great circle, the pole does <em>not</em> - * belong to it. - * </p> - * @return pole of the circle - * @see #getXAxis() - * @see #getYAxis() - */ - public Vector3D getPole() { - return pole; - } - - /** Get the arc of the instance that lies inside the other circle. - * @param other other circle - * @return arc of the instance that lies inside the other circle - */ - public Arc getInsideArc(final Circle other) { - final double alpha = getPhase(other.pole); - final double halfPi = 0.5 * FastMath.PI; - return new Arc(alpha - halfPi, alpha + halfPi, tolerance); - } - - /** {@inheritDoc} */ - public SubCircle wholeHyperplane() { - return new SubCircle(this, new ArcsSet(tolerance)); - } - - /** Build a region covering the whole space. - * @return a region containing the instance (really a {@link - * SphericalPolygonsSet SphericalPolygonsSet} instance) - */ - public SphericalPolygonsSet wholeSpace() { - return new SphericalPolygonsSet(tolerance); - } - - /** {@inheritDoc} - * @see #getOffset(Vector3D) - */ - public double getOffset(final Point<Sphere2D> point) { - return getOffset(((S2Point) point).getVector()); - } - - /** Get the offset (oriented distance) of a direction. - * <p>The offset is defined as the angular distance between the - * circle center and the direction minus the circle radius. It - * is therefore 0 on the circle, positive for directions outside of - * the cone delimited by the circle, and negative inside the cone.</p> - * @param direction direction to check - * @return offset of the direction - * @see #getOffset(Point) - */ - public double getOffset(final Vector3D direction) { - return Vector3D.angle(pole, direction) - 0.5 * FastMath.PI; - } - - /** {@inheritDoc} */ - public boolean sameOrientationAs(final Hyperplane<Sphere2D> other) { - final Circle otherC = (Circle) other; - return Vector3D.dotProduct(pole, otherC.pole) >= 0.0; - } - - /** Get a {@link org.apache.commons.math3.geometry.partitioning.Transform - * Transform} embedding a 3D rotation. - * @param rotation rotation to use - * @return a new transform that can be applied to either {@link - * Point Point}, {@link Circle Line} or {@link - * org.apache.commons.math3.geometry.partitioning.SubHyperplane - * SubHyperplane} instances - */ - public static Transform<Sphere2D, Sphere1D> getTransform(final Rotation rotation) { - return new CircleTransform(rotation); - } - - /** Class embedding a 3D rotation. */ - private static class CircleTransform implements Transform<Sphere2D, Sphere1D> { - - /** Underlying rotation. */ - private final Rotation rotation; - - /** Build a transform from a {@code Rotation}. - * @param rotation rotation to use - */ - public CircleTransform(final Rotation rotation) { - this.rotation = rotation; - } - - /** {@inheritDoc} */ - public S2Point apply(final Point<Sphere2D> point) { - return new S2Point(rotation.applyTo(((S2Point) point).getVector())); - } - - /** {@inheritDoc} */ - public Circle apply(final Hyperplane<Sphere2D> hyperplane) { - final Circle circle = (Circle) hyperplane; - return new Circle(rotation.applyTo(circle.pole), - rotation.applyTo(circle.x), - rotation.applyTo(circle.y), - circle.tolerance); - } - - /** {@inheritDoc} */ - public SubHyperplane<Sphere1D> apply(final SubHyperplane<Sphere1D> sub, - final Hyperplane<Sphere2D> original, - final Hyperplane<Sphere2D> transformed) { - // as the circle is rotated, the limit angles are rotated too - return sub; - } - - } - -} http://git-wip-us.apache.org/repos/asf/commons-math/blob/a7b4803f/src/main/java/org/apache/commons/math3/geometry/spherical/twod/Edge.java ---------------------------------------------------------------------- diff --git a/src/main/java/org/apache/commons/math3/geometry/spherical/twod/Edge.java b/src/main/java/org/apache/commons/math3/geometry/spherical/twod/Edge.java deleted file mode 100644 index a9ccb08..0000000 --- a/src/main/java/org/apache/commons/math3/geometry/spherical/twod/Edge.java +++ /dev/null @@ -1,222 +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.List; - -import org.apache.commons.math3.geometry.euclidean.threed.Vector3D; -import org.apache.commons.math3.geometry.spherical.oned.Arc; -import org.apache.commons.math3.util.FastMath; -import org.apache.commons.math3.util.MathUtils; - -/** Spherical polygons boundary edge. - * @see SphericalPolygonsSet#getBoundaryLoops() - * @see Vertex - * @since 3.3 - */ -public class Edge { - - /** Start vertex. */ - private final Vertex start; - - /** End vertex. */ - private Vertex end; - - /** Length of the arc. */ - private final double length; - - /** Circle supporting the edge. */ - private final Circle circle; - - /** Build an edge not contained in any node yet. - * @param start start vertex - * @param end end vertex - * @param length length of the arc (it can be greater than \( \pi \)) - * @param circle circle supporting the edge - */ - Edge(final Vertex start, final Vertex end, final double length, final Circle circle) { - - this.start = start; - this.end = end; - this.length = length; - this.circle = circle; - - // connect the vertices back to the edge - start.setOutgoing(this); - end.setIncoming(this); - - } - - /** Get start vertex. - * @return start vertex - */ - public Vertex getStart() { - return start; - } - - /** Get end vertex. - * @return end vertex - */ - public Vertex getEnd() { - return end; - } - - /** Get the length of the arc. - * @return length of the arc (can be greater than \( \pi \)) - */ - public double getLength() { - return length; - } - - /** Get the circle supporting this edge. - * @return circle supporting this edge - */ - public Circle getCircle() { - return circle; - } - - /** Get an intermediate point. - * <p> - * The angle along the edge should normally be between 0 and {@link #getLength()} - * in order to remain within edge limits. However, there are no checks on the - * value of the angle, so user can rebuild the full circle on which an edge is - * defined if they want. - * </p> - * @param alpha angle along the edge, counted from {@link #getStart()} - * @return an intermediate point - */ - public Vector3D getPointAt(final double alpha) { - return circle.getPointAt(alpha + circle.getPhase(start.getLocation().getVector())); - } - - /** Connect the instance with a following edge. - * @param next edge following the instance - */ - void setNextEdge(final Edge next) { - end = next.getStart(); - end.setIncoming(this); - end.bindWith(getCircle()); - } - - /** Split the edge. - * <p> - * Once split, this edge is not referenced anymore by the vertices, - * it is replaced by the two or three sub-edges and intermediate splitting - * vertices are introduced to connect these sub-edges together. - * </p> - * @param splitCircle circle splitting the edge in several parts - * @param outsideList list where to put parts that are outside of the split circle - * @param insideList list where to put parts that are inside the split circle - */ - void split(final Circle splitCircle, - final List<Edge> outsideList, final List<Edge> insideList) { - - // get the inside arc, synchronizing its phase with the edge itself - final double edgeStart = circle.getPhase(start.getLocation().getVector()); - final Arc arc = circle.getInsideArc(splitCircle); - final double arcRelativeStart = MathUtils.normalizeAngle(arc.getInf(), edgeStart + FastMath.PI) - edgeStart; - final double arcRelativeEnd = arcRelativeStart + arc.getSize(); - final double unwrappedEnd = arcRelativeEnd - MathUtils.TWO_PI; - - // build the sub-edges - final double tolerance = circle.getTolerance(); - Vertex previousVertex = start; - if (unwrappedEnd >= length - tolerance) { - - // the edge is entirely contained inside the circle - // we don't split anything - insideList.add(this); - - } else { - - // there are at least some parts of the edge that should be outside - // (even is they are later be filtered out as being too small) - double alreadyManagedLength = 0; - if (unwrappedEnd >= 0) { - // the start of the edge is inside the circle - previousVertex = addSubEdge(previousVertex, - new Vertex(new S2Point(circle.getPointAt(edgeStart + unwrappedEnd))), - unwrappedEnd, insideList, splitCircle); - alreadyManagedLength = unwrappedEnd; - } - - if (arcRelativeStart >= length - tolerance) { - // the edge ends while still outside of the circle - if (unwrappedEnd >= 0) { - previousVertex = addSubEdge(previousVertex, end, - length - alreadyManagedLength, outsideList, splitCircle); - } else { - // the edge is entirely outside of the circle - // we don't split anything - outsideList.add(this); - } - } else { - // the edge is long enough to enter inside the circle - previousVertex = addSubEdge(previousVertex, - new Vertex(new S2Point(circle.getPointAt(edgeStart + arcRelativeStart))), - arcRelativeStart - alreadyManagedLength, outsideList, splitCircle); - alreadyManagedLength = arcRelativeStart; - - if (arcRelativeEnd >= length - tolerance) { - // the edge ends while still inside of the circle - previousVertex = addSubEdge(previousVertex, end, - length - alreadyManagedLength, insideList, splitCircle); - } else { - // the edge is long enough to exit outside of the circle - previousVertex = addSubEdge(previousVertex, - new Vertex(new S2Point(circle.getPointAt(edgeStart + arcRelativeStart))), - arcRelativeStart - alreadyManagedLength, insideList, splitCircle); - alreadyManagedLength = arcRelativeStart; - previousVertex = addSubEdge(previousVertex, end, - length - alreadyManagedLength, outsideList, splitCircle); - } - } - - } - - } - - /** Add a sub-edge to a list if long enough. - * <p> - * If the length of the sub-edge to add is smaller than the {@link Circle#getTolerance()} - * tolerance of the support circle, it will be ignored. - * </p> - * @param subStart start of the sub-edge - * @param subEnd end of the sub-edge - * @param subLength length of the sub-edge - * @param splitCircle circle splitting the edge in several parts - * @param list list where to put the sub-edge - * @return end vertex of the edge ({@code subEnd} if the edge was long enough and really - * added, {@code subStart} if the edge was too small and therefore ignored) - */ - private Vertex addSubEdge(final Vertex subStart, final Vertex subEnd, final double subLength, - final List<Edge> list, final Circle splitCircle) { - - if (subLength <= circle.getTolerance()) { - // the edge is too short, we ignore it - return subStart; - } - - // really add the edge - subEnd.bindWith(splitCircle); - final Edge edge = new Edge(subStart, subEnd, subLength, circle); - list.add(edge); - return subEnd; - - } - -}
