Merge pull request #187 from Esri/stolstov/serialize_quadtree

Add serialization for QuadTree and related classes

Author: stolstov

src/main/java/com/esri/core/geometry/AttributeStreamOfInt32.java

@@ -1,5 +1,5 @@
 /*
- Copyright 1995-2017 Esri
+ Copyright 1995-2018 Esri
 
    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.
@@ -27,14 +27,20 @@
 
 import com.esri.core.geometry.VertexDescription.Persistence;
 
+import java.io.IOException;
+import java.io.ObjectStreamException;
+import java.io.Serializable;
 import java.nio.ByteBuffer;
+import java.nio.IntBuffer;
 import java.util.Arrays;
 
 import static com.esri.core.geometry.SizeOf.SIZE_OF_ATTRIBUTE_STREAM_OF_INT32;
 import static com.esri.core.geometry.SizeOf.sizeOfIntArray;
 
-final class AttributeStreamOfInt32 extends AttributeStreamBase {
-	private int[] m_buffer = null;
+final class AttributeStreamOfInt32 extends AttributeStreamBase implements Serializable {
+	private static final long serialVersionUID = 1L;
+	
+	transient private int[] m_buffer = null;
 	private int m_size;
 
 	public void reserve(int reserve)
@@ -594,7 +600,6 @@ private void _selfWriteRangeImpl(int toElement, int count, int fromElement,
 		// reverse what we written
 		int j = toElement;
 		int offset = toElement + count - stride;
-		int dj = stride;
 		for (int i = 0, n = count / 2; i < n; i++) {
 			for (int k = 0; k < stride; k++) {
 				int v = m_buffer[j + k];
@@ -728,4 +733,49 @@ void quicksort(int leftIn, int rightIn, IntComparator compare,
 	public void sort(int start, int end) {
 		Arrays.sort(m_buffer, start, end);
 	}
+	
+	private void writeObject(java.io.ObjectOutputStream stream)
+			throws IOException {
+		stream.defaultWriteObject();
+		IntBuffer intBuf = null;
+		byte[] bytes = null;
+		for (int i = 0; i < m_size;) {
+			int n = Math.min(32, m_size - i);
+			if (bytes == null) {
+				bytes = new byte[n * 4]; //32 elements at a time
+				ByteBuffer buf = ByteBuffer.wrap(bytes);
+				intBuf = buf.asIntBuffer();
+			}
+			intBuf.rewind();
+			intBuf.put(m_buffer, i, n);
+			stream.write(bytes, 0, n * 4);
+			i += n;
+		}
+	}
+
+	private void readObject(java.io.ObjectInputStream stream)
+			throws IOException, ClassNotFoundException {
+		stream.defaultReadObject();
+		m_buffer = new int[m_size];
+		IntBuffer intBuf = null;
+		byte[] bytes = null;
+		for (int i = 0; i < m_size;) {
+			int n = Math.min(32, m_size - i);
+			if (bytes == null) {
+				bytes = new byte[n * 4]; //32 elements at a time
+				ByteBuffer buf = ByteBuffer.wrap(bytes);
+				intBuf = buf.asIntBuffer();
+			}
+			stream.read(bytes, 0, n * 4);
+			intBuf.rewind();
+			intBuf.get(m_buffer, i, n);
+			i += n;
+		}
+	}
+	
+	@SuppressWarnings("unused")
+	private void readObjectNoData() throws ObjectStreamException {
+		m_buffer = new int[2];
+		m_size = 0;
+	}
 }

src/main/java/com/esri/core/geometry/QuadTree.java

@@ -1,5 +1,5 @@
 /*
- Copyright 1995-2015 Esri
+ Copyright 1995-2018 Esri
 
    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.
@@ -25,7 +25,11 @@
 
 package com.esri.core.geometry;
 
-public class QuadTree {
+import java.io.Serializable;
+
+public class QuadTree implements Serializable {
+	private static final long serialVersionUID = 1L;
+	
 	public static final class QuadTreeIterator {
 		/**
 		 * Resets the iterator to an starting state on the QuadTree. If the

src/main/java/com/esri/core/geometry/QuadTreeImpl.java

@@ -1,5 +1,5 @@
 /*
- Copyright 1995-2015 Esri
+ Copyright 1995-2018 Esri
 
    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.
@@ -23,9 +23,15 @@
  */
 package com.esri.core.geometry;
 
+import java.io.IOException;
+import java.io.InvalidObjectException;
+import java.io.ObjectStreamException;
+import java.io.Serializable;
 import java.util.ArrayList;
 
-class QuadTreeImpl {
+class QuadTreeImpl implements Serializable {
+	private static final long serialVersionUID = 1L;
+	
 	static final class QuadTreeIteratorImpl {
 		/**
 		 * Resets the iterator to an starting state on the Quad_tree_impl. If
@@ -1248,19 +1254,28 @@ private void set_data_values_(int data_handle, int element, Envelope2D bounding_
 	private Envelope2D m_data_extent;
 	private StridedIndexTypeCollection m_quad_tree_nodes;
 	private StridedIndexTypeCollection m_element_nodes;
-	private ArrayList<Data> m_data;
+	transient private ArrayList<Data> m_data;
 	private AttributeStreamOfInt32 m_free_data;
 	private int m_root;
 	private int m_height;
 	private boolean m_b_store_duplicates;
 
-	private int m_quadrant_mask = 3;
-	private int m_height_bit_shift = 2;
-	private int m_flushing_count = 5;
+	final static private int m_quadrant_mask = 3;
+	final static private int m_height_bit_shift = 2;
+	final static private int m_flushing_count = 5;
 
 	static final class Data {
 		int element;
 		Envelope2D box;
+		
+		Data() {
+		}
+		
+		Data(int element_, double x1, double y1, double x2, double y2) {
+			element = element_;
+			box = new Envelope2D();
+			box.setCoords(x1, y1, x2, y2);
+		}
 
 		Data(int element_, Envelope2D box_) {
 			element = element_;
@@ -1269,6 +1284,57 @@ static final class Data {
 		}
 	}
 
+	private void writeObject(java.io.ObjectOutputStream stream)
+			throws IOException {
+		stream.defaultWriteObject();
+		stream.writeInt(m_data.size());
+		for (int i = 0, n = m_data.size(); i < n; ++i) {
+			Data d = m_data.get(i);
+			if (d != null) {
+				stream.writeByte(1);
+				stream.writeInt(d.element);
+				stream.writeDouble(d.box.xmin);
+				stream.writeDouble(d.box.ymin);
+				stream.writeDouble(d.box.xmax);
+				stream.writeDouble(d.box.ymax);
+			}
+			else {
+				stream.writeByte(0);
+			}
+				
+		}
+	}
+
+	private void readObject(java.io.ObjectInputStream stream)
+			throws IOException, ClassNotFoundException {
+		stream.defaultReadObject();
+		int dataSize = stream.readInt();
+		m_data = new ArrayList<Data>(dataSize);
+		for (int i = 0, n = dataSize; i < n; ++i) {
+			int b = stream.readByte();
+			if (b == 1) {
+				int elm = stream.readInt();
+				double x1 = stream.readDouble();
+				double y1 = stream.readDouble();
+				double x2 = stream.readDouble();
+				double y2 = stream.readDouble();
+				Data d = new Data(elm, x1, y1, x2, y2);
+				m_data.add(d);
+			}
+			else if (b == 0) {
+				m_data.add(null);
+			}
+			else {
+				throw new IOException();
+			}
+		}
+	}
+	
+	@SuppressWarnings("unused")
+	private void readObjectNoData() throws ObjectStreamException {
+		throw new InvalidObjectException("Stream data required");
+	}
+
     /* m_quad_tree_nodes
     * 0: m_north_east_child
     * 1: m_north_west_child

src/main/java/com/esri/core/geometry/StridedIndexTypeCollection.java

@@ -1,5 +1,5 @@
 /*
- Copyright 1995-2015 Esri
+ Copyright 1995-2018 Esri
 
    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.
@@ -23,13 +23,17 @@
  */
 package com.esri.core.geometry;
 
+import java.io.Serializable;
+
 /**
  * A collection of strides of Index_type elements. To be used when one needs a
  * collection of homogeneous elements that contain only integer fields (i.e.
  * structs with Index_type members) Recycles the strides. Allows for constant
  * time creation and deletion of an element.
  */
-final class StridedIndexTypeCollection {
+final class StridedIndexTypeCollection implements Serializable {
+	private static final long serialVersionUID = 1L;
+	
 	private int[][] m_buffer = null;
 	private int m_firstFree = -1;
 	private int m_last = 0;

src/test/java/com/esri/core/geometry/TestSerialization.java

@@ -1,5 +1,5 @@
 /*
- Copyright 1995-2017 Esri
+ Copyright 1995-2018 Esri
 
    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.
@@ -26,7 +26,6 @@
 
 import java.io.ByteArrayInputStream;
 import java.io.ByteArrayOutputStream;
-import java.io.FileOutputStream;
 import java.io.InputStream;
 import java.io.ObjectInputStream;
 import java.io.ObjectOutputStream;
@@ -401,4 +400,97 @@ public void testSerializeEnvelope2D() {
 		}
 	}
 
+	public void testAttributeStreamOfInt32() {
+		AttributeStreamOfInt32 a = new AttributeStreamOfInt32(0);
+		for (int i = 0; i < 100; i++)
+			a.add(i);
+		
+		try {
+			// serialize
+			ByteArrayOutputStream baos = new ByteArrayOutputStream();
+			ObjectOutputStream os = new ObjectOutputStream(baos);
+			os.writeObject(a);
+			os.close();
+			baos.close();
+
+			// deserialize
+			ByteArrayInputStream bais = new ByteArrayInputStream(
+					baos.toByteArray());
+			ObjectInputStream in = new ObjectInputStream(bais);
+			AttributeStreamOfInt32 aOut = (AttributeStreamOfInt32) in.readObject();
+			in.close();
+			bais.close();
+
+			assertTrue(aOut.size() == a.size());
+			for (int i = 0; i < 100; i++)
+				assertTrue(aOut.get(i) == a.get(i));
+
+		} catch (Exception e) {
+			fail("AttributeStreamOfInt32 serialization failure");
+		}
+		
+	}
+	
+	@Test
+	public void testQuadTree() {
+		MultiPoint mp = new MultiPoint();
+		int r = 124124;
+		for (int i = 0; i < 100; ++i) {
+			r = NumberUtils.nextRand(r);
+			int x = r;
+			r = NumberUtils.nextRand(r);
+			int y = r;
+			mp.add(x, y);
+		}
+		
+		Envelope2D extent = new Envelope2D();
+		mp.queryEnvelope2D(extent);
+		QuadTree quadTree = new QuadTree(extent, 8);
+		Envelope2D boundingbox = new Envelope2D();
+		Point2D pt;
+
+		for (int i = 0; i < mp.getPointCount(); i++) {
+			pt = mp.getXY(i);
+			boundingbox.setCoords(pt.x, pt.y, pt.x, pt.y);
+			quadTree.insert(i, boundingbox, -1);
+		}
+		
+		try {
+			// serialize
+			ByteArrayOutputStream baos = new ByteArrayOutputStream();
+			ObjectOutputStream os = new ObjectOutputStream(baos);
+			os.writeObject(quadTree);
+			os.close();
+			baos.close();
+
+			// deserialize
+			ByteArrayInputStream bais = new ByteArrayInputStream(
+					baos.toByteArray());
+			ObjectInputStream in = new ObjectInputStream(bais);
+			QuadTree qOut = (QuadTree) in.readObject();
+			in.close();
+			bais.close();
+
+			assertTrue(quadTree.getElementCount() == qOut.getElementCount());
+			QuadTree.QuadTreeIterator iter1 = quadTree.getIterator();
+			QuadTree.QuadTreeIterator iter2 = qOut.getIterator();
+			int h1 = iter1.next();
+			int h2 = iter2.next();
+			for (; h1 != -1 && h2 != -1; h1 = iter1.next(), h2 = iter2.next()) {
+				assertTrue(quadTree.getElement(h1) == qOut.getElement(h2));
+				assertTrue(quadTree.getElementExtent(h1).equals(qOut.getElementExtent(h2)));
+				assertTrue(quadTree.getExtent(quadTree.getQuad(h1)).equals(qOut.getExtent(qOut.getQuad(h2))));
+				int c1 = quadTree.getSubTreeElementCount(quadTree.getQuad(h1));
+				int c2 = qOut.getSubTreeElementCount(qOut.getQuad(h2));
+				assertTrue(c1 == c2);
+			}
+			
+			assertTrue(h1 == -1 && h2 == -1);
+
+			assertTrue(quadTree.getDataExtent().equals(qOut.getDataExtent()));
+		} catch (Exception e) {
+			fail("QuadTree serialization failure");
+		}
+		
+	}
 }