open source release 2013-03-21

Author: stolstov

src/com/esri/core/geometry/AttributeStreamBase.java

@@ -0,0 +1,179 @@
+/*
+ Copyright 1995-2013 Esri
+
+   Licensed 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.
+
+ For additional information, contact:
+ Environmental Systems Research Institute, Inc.
+ Attn: Contracts Dept
+ 380 New York Street
+ Redlands, California, USA 92373
+
+ email: contracts@esri.com
+ */
+package com.esri.core.geometry;
+
+class Boundary {
+	static Geometry calculate(Geometry geom, ProgressTracker progress_tracker) {
+		int gt = geom.getType().value();
+		if (gt == Geometry.GeometryType.Polygon) {
+			Polyline dst = new Polyline(geom.getDescription());
+			if (!geom.isEmpty())
+				geom.copyTo(dst);
+
+			return dst;
+		} else if (gt == Geometry.GeometryType.Polyline) {
+			return calculatePolylineBoundary_(geom._getImpl(), progress_tracker);
+		} else if (gt == Geometry.GeometryType.Envelope) {
+			Polyline dst = new Polyline(geom.getDescription());
+			if (!geom.isEmpty())
+				dst.addEnvelope((Envelope) geom, false);
+
+			return dst;
+		} else if (Geometry.isSegment(gt)) {
+			MultiPoint mp = new MultiPoint(geom.getDescription());
+			if (!geom.isEmpty() && !((Segment) geom).isClosed()) {
+				Point pt = new Point();
+				((Segment) geom).queryStart(pt);
+				mp.add(pt);
+				((Segment) geom).queryEnd(pt);
+				mp.add(pt);
+			}
+			return mp;
+		} else if (Geometry.isPoint(gt)) {
+			// returns empty point for points and multipoints.
+			return null;
+		}
+
+		throw new IllegalArgumentException();
+	}
+
+	private static final class MultiPathImplBoundarySorter extends ClassicSort {
+		AttributeStreamOfDbl m_xy;
+
+		static final class CompareIndices extends
+				AttributeStreamOfInt32.IntComparator {
+			AttributeStreamOfDbl m_xy;
+			Point2D pt1_helper;
+			Point2D pt2_helper;
+
+			CompareIndices(AttributeStreamOfDbl xy) {
+				m_xy = xy;
+				pt1_helper = new Point2D();
+				pt2_helper = new Point2D();
+			}
+
+			@Override
+			public int compare(int v1, int v2) {
+				m_xy.read(2 * v1, pt1_helper);
+				m_xy.read(2 * v2, pt2_helper);
+				return pt1_helper.compare(pt2_helper);
+			}
+		}
+
+		MultiPathImplBoundarySorter(AttributeStreamOfDbl xy) {
+			m_xy = xy;
+		}
+
+		@Override
+		public void userSort(int begin, int end, AttributeStreamOfInt32 indices) {
+			indices.Sort(begin, end, new CompareIndices(m_xy));
+		}
+
+		@Override
+		public double getValue(int index) {
+			return m_xy.read(2 * index + 1);
+		}
+	}
+
+	static MultiPoint calculatePolylineBoundary_(Object impl,
+			ProgressTracker progress_tracker) {
+		MultiPathImpl mpImpl = (MultiPathImpl) impl;
+		MultiPoint dst = new MultiPoint(mpImpl.getDescription());
+		if (!mpImpl.isEmpty()) {
+			AttributeStreamOfInt32 indices = new AttributeStreamOfInt32(0);
+			indices.reserve(mpImpl.getPathCount() * 2);
+			for (int ipath = 0, nPathCount = mpImpl.getPathCount(); ipath < nPathCount; ipath++) {
+				int path_size = mpImpl.getPathSize(ipath);
+				if (path_size > 0 && !mpImpl.isClosedPathInXYPlane(ipath))// closed
+																			// paths
+																			// of
+																			// polyline
+																			// do
+																			// not
+																			// contribute
+																			// to
+																			// the
+																			// boundary.
+				{
+					int start = mpImpl.getPathStart(ipath);
+					indices.add(start);
+					int end = mpImpl.getPathEnd(ipath) - 1;
+					indices.add(end);
+				}
+			}
+			if (indices.size() > 0) {
+				BucketSort sorter = new BucketSort();
+				AttributeStreamOfDbl xy = (AttributeStreamOfDbl) (mpImpl
+						.getAttributeStreamRef(VertexDescription.Semantics.POSITION));
+				sorter.sort(indices, 0, indices.size(),
+						new MultiPathImplBoundarySorter(xy));
+				Point2D ptPrev = new Point2D();
+				xy.read(2 * indices.get(0), ptPrev);
+				int ind = 0;
+				int counter = 1;
+				Point point = new Point();
+				Point2D pt = new Point2D();
+				for (int i = 1, n = indices.size(); i < n; i++) {
+					xy.read(2 * indices.get(i), pt);
+					if (pt.isEqual(ptPrev)) {
+						if (indices.get(ind) > indices.get(i)) {
+							// remove duplicate point
+							indices.set(ind, NumberUtils.intMax());
+							ind = i;// just for the heck of it, have the first
+									// point in the order to be added to the
+									// boundary.
+						} else
+							indices.set(i, NumberUtils.intMax());
+
+						counter++;
+					} else {
+						if ((counter & 1) == 0) {// remove boundary point
+							indices.set(ind, NumberUtils.intMax());
+						}
+
+						ptPrev.setCoords(pt);
+						ind = i;
+						counter = 1;
+					}
+				}
+
+				if ((counter & 1) == 0) {// remove the point
+					indices.set(ind, NumberUtils.intMax());
+				}
+
+				indices.sort(0, indices.size());
+
+				for (int i = 0, n = indices.size(); i < n; i++) {
+					if (indices.get(i) == NumberUtils.intMax())
+						break;
+
+					mpImpl.getPointByVal(indices.get(i), point);
+					dst.add(point);
+				}
+			}
+		}
+
+		return dst;
+	}
+}

src/com/esri/core/geometry/AttributeStreamOfDbl.java

@@ -0,0 +1,184 @@
+/*
+ Copyright 1995-2013 Esri
+
+   Licensed 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.
+
+ For additional information, contact:
+ Environmental Systems Research Institute, Inc.
+ Attn: Contracts Dept
+ 380 New York Street
+ Redlands, California, USA 92373
+
+ email: contracts@esri.com
+ */
+package com.esri.core.geometry;
+
+final class BucketSort {
+	AttributeStreamOfInt32 m_buckets;
+	AttributeStreamOfInt32 m_bucketed_indices;
+	double m_min_value;
+	double m_max_value;
+	double m_dy;
+
+	static int MAXBUCKETS = 65536;
+
+	public BucketSort() {
+		m_buckets = new AttributeStreamOfInt32(0);
+		m_bucketed_indices = new AttributeStreamOfInt32(0);
+		m_min_value = 1;
+		m_max_value = -1;
+		m_dy = NumberUtils.TheNaN;
+	}
+
+	/**
+	 * Executes sort on the Bucket_sort. The result is fed into the indices
+	 * array in the range between begin (inclusive) and end (exclusive). Uses
+	 * user supplied sorter to execute sort on each bucket. Users either supply
+	 * the sorter and use this method of Bucket_sort class, or use other methods
+	 * to form the buckets and take care of bucket sorting themselves.
+	 */
+	public void sort(AttributeStreamOfInt32 indices, int begin, int end,
+			ClassicSort sorter) {
+		if (end - begin < 32) {
+			sorter.userSort(begin, end, indices);
+			return;
+		}
+		boolean b_fallback = true;
+		try {
+			double miny = NumberUtils.positiveInf();
+			double maxy = NumberUtils.negativeInf();
+			for (int i = begin; i < end; i++) {
+				double y = sorter.getValue(indices.get(i));
+				if (y < miny)
+					miny = y;
+				if (y > maxy)
+					maxy = y;
+			}
+
+			if (reset(end - begin, miny, maxy, end - begin)) {
+				for (int i = begin; i < end; i++) {
+					int vertex = indices.get(i);
+					double y = sorter.getValue(vertex);
+					int bucket = getBucket(y);
+					m_buckets.set(bucket, m_buckets.get(bucket) + 1);// counting
+																		// values
+																		// in a
+																		// bucket.
+					m_bucketed_indices.write(i - begin, vertex);
+				}
+
+				// Recalculate buckets to contain start positions of buckets.
+				int c = m_buckets.get(0);
+				m_buckets.set(0, 0);
+				for (int i = 1, n = m_buckets.size(); i < n; i++) {
+					int b = m_buckets.get(i);
+					m_buckets.set(i, c);
+					c += b;
+				}
+
+				for (int i = begin; i < end; i++) {
+					int vertex = m_bucketed_indices.read(i - begin);
+					double y = sorter.getValue(vertex);
+					int bucket = getBucket(y);
+					int bucket_index = m_buckets.get(bucket);
+					indices.set(bucket_index + begin, vertex);
+					m_buckets.set(bucket, bucket_index + 1);
+				}
+
+				b_fallback = false;
+			}
+		} catch (Exception e) {
+			m_buckets.resize(0);
+			m_bucketed_indices.resize(0);
+		}
+
+		if (b_fallback) {
+			sorter.userSort(begin, end, indices);
+			return;
+		}
+
+		int j = 0;
+		for (int i = 0, n = m_buckets.size(); i < n; i++) {
+			int j0 = j;
+			j = m_buckets.get(i);
+			if (j > j0)
+				sorter.userSort(begin + j0, begin + j, indices);
+		}
+		assert (j == end);
+
+		if (getBucketCount() > 100) // some heuristics to preserve memory
+		{
+			m_buckets.resize(0);
+			m_bucketed_indices.resize(0);
+		}
+	}
+
+	/**
+	 * Clears and resets Bucket_sort to the new state, preparing for the
+	 * accumulation of new data.
+	 * 
+	 * @param bucket_count
+	 *            - the number of buckets. Usually equal to the number of
+	 *            elements to sort.
+	 * @param min_value
+	 *            - the minimum value of elements to sort.
+	 * @param max_value
+	 *            - the maximum value of elements to sort.
+	 * @param capacity
+	 *            - the number of elements to sort (-1 if not known). The
+	 *            bucket_count are usually equal.
+	 * @return Returns False, if the bucket sort cannot be used with the given
+	 *         parameters. The method also can throw out of memory exception. In
+	 *         the later case, one should fall back to the regular sort.
+	 */
+	private boolean reset(int bucket_count, double min_value, double max_value,
+			int capacity) {
+		if (bucket_count < 2 || max_value == min_value)
+			return false;
+
+		int bc = Math.min(MAXBUCKETS, bucket_count);
+		m_buckets.reserve(bc);
+		m_buckets.resize(bc);
+		m_buckets.setRange(0, 0, m_buckets.size());
+		m_min_value = min_value;
+		m_max_value = max_value;
+		m_bucketed_indices.resize(capacity);
+
+		m_dy = (max_value - min_value) / (bc - 1);
+		return true;
+	}
+
+	/**
+	 * Adds new element to the bucket builder. The value must be between
+	 * min_value and max_value.
+	 * 
+	 * @param The
+	 *            value used for bucketing.
+	 * @param The
+	 *            index of the element to store in the buffer. Usually it is an
+	 *            index into some array, where the real elements are stored.
+	 */
+	private int getBucket(double value) {
+		assert (value >= m_min_value && value <= m_max_value);
+		int bucket = (int) ((value - m_min_value) / m_dy);
+		return bucket;
+	}
+
+	/**
+	 * Returns the bucket count.
+	 */
+	private int getBucketCount() {
+		return m_buckets.size();
+	}
+
+}