@Override public void setBin (int x, int y, T value) { List<T> originalValue = _base.getBin(x, y); List<T> newValue = new ArrayList<>(originalValue); newValue.set(_slice, value); _base.setBin(x, y, newValue); }
@Override public void setBin (int x, int y, T value) { Map<Integer, T> originalValue = _base.getBin(x, y); Map<Integer, T> newValue = new HashMap<>(originalValue); newValue.put(_slice, value); _base.setBin(x, y, newValue); }
@Override public void setBin(int x, int y, List<T> value) { if (x < 0 || x >= getDefinition().getXBins()) { throw new IllegalArgumentException("Bin x index is outside of tile's valid bin range"); } if (y < 0 || y >= getDefinition().getYBins()) { throw new IllegalArgumentException("Bin y index is outside of tile's valid bin range"); } _base.setBin( x, y, value ); }
@Override public void setBin(int x, int y, T value) { if (x < 0 || x >= getDefinition().getXBins()) { throw new IllegalArgumentException("Bin x index is outside of tile's valid bin range"); } if (y < 0 || y >= getDefinition().getYBins()) { throw new IllegalArgumentException("Bin y index is outside of tile's valid bin range"); } _source.setBin(x + _xOffset, y + _yOffset, value); }
@Test public void testUnmodifiableBinReplacement () { List<Integer> binVal = new ArrayList<>(); binVal.add(3); binVal.add(4); binVal.add(5); TileData<List<Integer>> base = new DenseTileData<List<Integer>>(new TileIndex(0, 0, 0, 1, 1)); base.setBin(0, 0, Collections.unmodifiableList(binVal)); TileData<List<Integer>> slice = new DenseTileMultiSliceView<Integer>(base, Arrays.asList(2, 0)); slice.setBin(0, 0, Arrays.asList(6, 2)); Assert.assertEquals(2, base.getBin(0, 0).get(0).intValue()); Assert.assertEquals(4, base.getBin(0, 0).get(1).intValue()); Assert.assertEquals(6, base.getBin(0, 0).get(2).intValue()); Assert.assertEquals(3, binVal.get(0).intValue()); Assert.assertEquals(4, binVal.get(1).intValue()); Assert.assertEquals(5, binVal.get(2).intValue()); }
@Test public void testModifiableBinReplacement () { List<Integer> binVal = new ArrayList<>(); binVal.add(3); binVal.add(4); binVal.add(5); TileData<List<Integer>> base = new DenseTileData<List<Integer>>(new TileIndex(0, 0, 0, 1, 1)); base.setBin(0, 0, binVal); TileData<List<Integer>> slice = new DenseTileMultiSliceView<Integer>(base, Arrays.asList(2, 0)); slice.setBin(0, 0, Arrays.asList(6, 2)); Assert.assertEquals(2, base.getBin(0, 0).get(0).intValue()); Assert.assertEquals(4, base.getBin(0, 0).get(1).intValue()); Assert.assertEquals(6, base.getBin(0, 0).get(2).intValue()); Assert.assertEquals(2, binVal.get(0).intValue()); Assert.assertEquals(4, binVal.get(1).intValue()); Assert.assertEquals(6, binVal.get(2).intValue()); }
@Before public void setup () { // Create some data Random random = new Random(15485863); _scalarData = new DenseTileData<>(new TileIndex(0, 0, 0, 256, 256)); for (int x=0; x < BIN_SIZE; ++x) { for (int y=0; y < BIN_SIZE; ++y) { _scalarData.setBin(x, y, random.nextDouble()); } } // Random vector data for more complex types. _vectorData = new DenseTileData<>(new TileIndex(0, 0, 0, 256, 256)); for (int x=0; x < BIN_SIZE; ++x) { for (int y=0; y < BIN_SIZE; ++y) { List<Double> binData = new ArrayList<Double>(1); for (int i = 0; i < VECTOR_SIZE; i++) { binData.add(random.nextBoolean() ? random.nextDouble() : 0.0); } _vectorData.setBin(x, y, binData); } } }
private TileData<Double> createRandomTile () { TileIndex index = new TileIndex(0, 0, 0); TileData<Double> datum = new DenseTileData<>(index); for (int x=0; x<index.getXBins(); ++x) { for (int y=0; y<index.getYBins(); ++y) { datum.setBin(x, y, Math.random()); } } return datum; } private TileData<Double> addTiles (TileData<Double> a, TileData<Double> b) {
@Test public void testNullBinReplacement () { TileData<List<Integer>> base = new DenseTileData<List<Integer>>(new TileIndex(0, 0, 0, 1, 1), (List<Integer>) null); TileData<List<Integer>> slice = new DenseTileMultiSliceView<Integer>(base, Arrays.asList(2, 0)); slice.setBin(0, 0, Arrays.asList(4, 2)); Assert.assertEquals(2, base.getBin(0, 0).get(0).intValue()); Assert.assertNull( base.getBin(0, 0).get(1)); Assert.assertEquals(4, base.getBin(0, 0).get(2).intValue()); } @Test
@Test public void testBinRetrieval () { TileData<List<Integer>> base = new DenseTileData(new TileIndex(0, 0, 0, 1, 1)); base.setBin(0, 0, Arrays.asList(-0, -1, -2, -3, -4, -5, -6, -7)); TileData<List<Integer>> slice1 = new DenseTileMultiSliceView<Integer>(base, Arrays.asList(1, 3, 5, 7)); TileData<List<Integer>> slice2 = new DenseTileMultiSliceView<Integer>(base, Arrays.asList(6, 4, 2, 0)); List<Integer> b1 = slice1.getBin(0, 0); Assert.assertEquals(4, b1.size()); Assert.assertEquals(-1, b1.get(0).intValue()); Assert.assertEquals(-3, b1.get(1).intValue()); Assert.assertEquals(-5, b1.get(2).intValue()); Assert.assertEquals(-7, b1.get(3).intValue()); List<Integer> b2 = slice2.getBin(0, 0); Assert.assertEquals(4, b2.size()); Assert.assertEquals(-6, b2.get(0).intValue()); Assert.assertEquals(-4, b2.get(1).intValue()); Assert.assertEquals(-2, b2.get(2).intValue()); Assert.assertEquals(-0, b2.get(3).intValue()); } }
@Test public void testStringIntPairArrayTileSerialization() throws IOException { TileSerializer<List<Pair<String, Integer>>> serializer = new StringIntPairArrayJsonSerializer(); TileIndex index = new TileIndex(0, 0, 0, 1, 1); TileData<List<Pair<String, Integer>>> tile = new DenseTileData<List<Pair<String,Integer>>>(index); List<Pair<String, Integer>> data = new ArrayList<Pair<String,Integer>>(); data.add(new Pair<String, Integer>("a", 1)); data.add(new Pair<String, Integer>("b", 2)); data.add(new Pair<String, Integer>("c", 3)); data.add(new Pair<String, Integer>("d", 4)); data.add(new Pair<String, Integer>("e", 5)); tile.setBin(0, 0, data); ByteArrayOutputStream baos = new ByteArrayOutputStream(); serializer.serialize(tile, baos); baos.flush(); baos.close(); byte[] buffer = baos.toByteArray(); ByteArrayInputStream bais = new ByteArrayInputStream(buffer); TileData<List<Pair<String, Integer>>> result = serializer.deserialize(index, bais); Assert.assertEquals(index, result.getDefinition()); List<Pair<String, Integer>> resultBin = result.getBin(0, 0); Assert.assertEquals(data.size(), resultBin.size()); for (int i=0; i<data.size(); ++i) { Assert.assertEquals(data.get(i), resultBin.get(i)); } }
@Test public void testMetaDataSerialization () throws Exception { TileIndex index = new TileIndex(0, 0, 0, 2, 2); TileData<Double> tile = new DenseTileData<>(index); tile.setBin(0, 0, 1.0); tile.setBin(0, 1, 2.0); tile.setBin(1, 0, 3.0); tile.setBin(1, 1, 4.0); tile.setMetaData("a", "abc"); tile.setMetaData("b", "bcd"); TileSerializer<Double> serializer = new KryoSerializer<Double>(new TypeDescriptor(Double.class)); ByteArrayOutputStream output = new ByteArrayOutputStream(); serializer.serialize(tile, output); output.flush(); output.close(); ByteArrayInputStream input = new ByteArrayInputStream(output.toByteArray()); TileData<Double> received = serializer.deserialize(index, input); Assert.assertEquals(2, received.getMetaDataProperties().size()); Assert.assertTrue(received.getMetaDataProperties().contains("a")); Assert.assertTrue(received.getMetaDataProperties().contains("b")); Assert.assertEquals("abc", received.getMetaData("a")); Assert.assertEquals("bcd", received.getMetaData("b")); }
public void testBackwardCompatbilitySerialize() throws IOException{ TestPyramidIO io = new TestPyramidIO(); TileSerializer<Double> serializer = new com.oculusinfo.binning.io.serialization.impl.BackwardCompatibilitySerializer(); TileIndex index = new TileIndex(0, 0, 0, 1, 1); TileData<Double> tile = new DenseTileData<Double>(index); tile.setBin(0, 0, 5.0); io.initializeForWrite("backwardsCompatibilityTest"); io.writeTiles("backwardsCompatibilityTest", serializer, Collections.singleton(tile)); List<TileData<Double>> tiles = io.readTiles("backwardsCompatibilityTest", serializer, Collections.singleton(index)); TileData<Double> tileOut = tiles.get(0); double dataOut = tileOut.getBin(0, 0); Assert.assertEquals(5.0, dataOut); }
@SafeVarargs final <T> void testRoundTrip(Class<? extends T> type, T... data) throws Exception { TileSerializer<T> serializer = new PrimitiveAvroSerializer<T>(type, CodecFactory.nullCodec()); // Create our tile int size = (int) Math.ceil(Math.sqrt(data.length)); TileData<T> input = new DenseTileData<>(new TileIndex(0, 0, 0, size, size)); for (int y=0; y<size; ++y) { for (int x=0; x<size; ++x) { int i = (x+size*y) % data.length; input.setBin(x, y, data[i]); } } // Send it round-trip through serialization ByteArrayOutputStream baos = new ByteArrayOutputStream(); serializer.serialize(input, baos); baos.flush(); baos.close(); ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray()); TileData<T> output = serializer.deserialize(new TileIndex(1, 1, 1, size, size), bais); // Test to make sure output matches input. Assert.assertEquals(input.getDefinition(), output.getDefinition()); for (int y=0; y<size; ++y) { for (int x=0; x<size; ++x) { Assert.assertEquals(input.getBin(x, y), output.getBin(x, y)); } } }
@Test public void testDoubleArrayTileSerialization() throws IOException { TileIndex index = new TileIndex(2, 0, 1, 10, 20); TileData<List<Double>> tile = new DenseTileData<List<Double>>(index); for (int x=0; x<10; ++x) { for (int y=0; y<20; ++y) { tile.setBin(x, y, Arrays.asList(1.0*x, 2.0*y)); } } PyramidIO io = new TestPyramidIO(); TileSerializer<List<Double>> serializer = new PrimitiveArrayAvroSerializer<>(Double.class, CodecFactory.nullCodec()); io.writeTiles(".", serializer, Collections.singleton(tile)); List<TileData<List<Double>>> tilesOut = io.readTiles(".", serializer, Collections.singleton(index)); Assert.assertEquals(1, tilesOut.size()); TileData<List<Double>> firstOut = tilesOut.get(0); Assert.assertEquals(tile.getDefinition(), firstOut.getDefinition()); for (int x = 0; x < tile.getDefinition().getXBins(); ++x) { for (int y = 0; y < tile.getDefinition().getYBins(); ++y) { List<Double> inData = tile.getBin(x, y); List<Double> outData = firstOut.getBin(x, y); Assert.assertEquals(inData.size(), outData.size()); for (int j=0; j<inData.size(); ++j) { Assert.assertEquals(inData.get(j), outData.get(j), 1E-12); } } } }
@SafeVarargs final <T> void testRoundTrip(Class<? extends T> type, T defaultBin, T... data) throws Exception { TileSerializer<T> serializer = new PrimitiveAvroSerializer<T>(type, CodecFactory.nullCodec()); // Create our tile int size = data.length; TileData<T> input = new SparseTileData<>(new TileIndex(0, 0, 0, size, size), defaultBin); for (int i=0; i<size; ++i) { input.setBin(i, i, data[i]); } // Send it round-trip through serialization ByteArrayOutputStream baos = new ByteArrayOutputStream(); serializer.serialize(input, baos); baos.flush(); baos.close(); ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray()); TileData<T> output = serializer.deserialize(new TileIndex(1, 1, 1, size, size), bais); // Test to make sure output matches input. Assert.assertEquals(input.getDefinition(), output.getDefinition()); for (int y=0; y<size; ++y) { for (int x=0; x<size; ++x) { Assert.assertEquals(input.getBin(x, y), output.getBin(x, y)); if (x == y) Assert.assertEquals(output.getBin(x, y), data[x]); else Assert.assertEquals(output.getBin(x, y), defaultBin); } } }
/** * Test if two serializers are equal, by creating a tile data, and making sure each reads the * output of the other. */ public static <T> void assertSerializersEqual (TileSerializer<T> expected, TileSerializer<T> actual, DataSource<T> random) throws Exception { int nX = 8; int nY = 8; TileIndex index = new TileIndex(4, 3, 2, nX, nY); TileData<T> data = new DenseTileData<>(index); for (int x=0; x<nX; ++x) { for (int y=0; y<nY; ++y) { data.setBin(x, y, random.create()); } } assertTilesEqual(data, roundTrip(data, expected, actual)); assertTilesEqual(data, roundTrip(data, actual, expected)); }
@Test public void testDoubleTileSerialization() throws IOException { TileIndex index = new TileIndex(2, 0, 1, 10, 20); TileData<Double> tile = new DenseTileData<Double>(index); for (int x=0; x<10; ++x) { for (int y=0; y<20; ++y) { tile.setBin(x, y, ((x+10*y)%7)/2.0); } } PyramidIO io = new TestPyramidIO(); TileSerializer<Double> serializer = new PrimitiveAvroSerializer<>(Double.class, CodecFactory.nullCodec()); io.writeTiles(".", serializer, Collections.singleton(tile)); List<TileData<Double>> tilesOut = io.readTiles(".", serializer, Collections.singleton(index)); Assert.assertEquals(1, tilesOut.size()); TileData<Double> firstOut = tilesOut.get(0); Assert.assertEquals(tile.getDefinition(), firstOut.getDefinition()); for (int x = 0; x < tile.getDefinition().getXBins(); ++x) { for (int y = 0; y < tile.getDefinition().getYBins(); ++y) { Assert.assertEquals(tile.getBin(x, y), firstOut.getBin(x, y), 1E-12); } } }
@Test public void writeReadAvroRoundTripTest () { FileBasedPyramidIO io = new FileBasedPyramidIO(new FileSystemPyramidSource(SOURCE_DIR, SOURCE_EXT)); TileSerializer<Integer> serializer = new PrimitiveAvroSerializer<>(Integer.class, CodecFactory.nullCodec()); ArrayList<TileData<Integer>> writeTiles = new ArrayList<>(); TileIndex index = new TileIndex( LEVEL, X_INDEX, Y_INDEX ); TileData<Integer> tile = new DenseTileData<>(index); for (int x=0; x<256; ++x) { for (int y=0; y<256; ++y) { tile.setBin(x, y, x+256*y); } } writeTiles.add(tile); writeAvroTiles(io, serializer, SOURCE_LAYER, writeTiles); List<TileData<Integer>> readTiles = readAvroTiles(io, serializer, SOURCE_LAYER); for (int i=0; i<writeTiles.size(); i++){ TileData<Integer> writeTile = writeTiles.get(i); TileIndex writeTileDef = writeTile.getDefinition(); TileData<Integer> readTile = readTiles.get(i); TileIndex readTileDef = readTile.getDefinition(); Assert.assertEquals(writeTileDef, readTileDef); for (int x = 0; x < writeTile.getDefinition().getXBins(); ++x) { for (int y = 0; y < writeTile.getDefinition().getYBins(); ++y) { Assert.assertEquals(writeTile.getBin(x, y), readTile.getBin(x, y)); } } } }