private void doCopy(List<TileIndex> toCopy) throws IOException { List<TileData<T>> tiles = _source.readTiles(_parameters._sourceId, _serializer, toCopy); _destination.writeTiles(_parameters._destinationId, _serializer, tiles); }
public <T> void copyPyramid (String pyramidId, int minLevel, int maxLevel, TileSerializer<T> serializer, int blockSize) throws IOException { // Parameters 2-4 aren't used except in live tiling, so dummy parameters are fine. _from.initializeForRead(pyramidId, 256, 256, null); _to.initializeForWrite(pyramidId); System.out.println("Writing metadata"); _to.writeMetaData(pyramidId, _from.readMetaData(pyramidId)); for (int level = minLevel; level <= maxLevel; ++level) { System.out.println("Copying level " + level); copyLevel(pyramidId, level, serializer, blockSize); } } public <T> void copyLevel (String pyramidId, int level, TileSerializer<T> serializer, int blockSize) throws IOException {
private void showCurrentTile () { if (null == _pyramidId) return; if (null == _pyramidIO) return; if (null == _levelField.getSelectedItem()) return; if (null == _xField.getSelectedItem()) return; if (null == _yField.getSelectedItem()) return; TileIndex index = new TileIndex((Integer) _levelField.getSelectedItem(), (Integer) _xField.getSelectedItem(), (Integer) _yField.getSelectedItem()); try { InputStream tileStream = _pyramidIO.getTileStream(_pyramidId, null, index); _tile = AvroJSONConverter.convert(tileStream); if (null == _tile) { _tileVis.setText(""); } else { _tileVis.setText(_tile.toString(2)); } } catch (Exception e) { _tileVis.setText(""); } }
private <T> void writeAvroTiles (PyramidIO pio, TileSerializer<T> serializer, String pyramidId, ArrayList<TileData<T>> tiles) { try { pio.initializeForWrite(pyramidId); pio.writeTiles(pyramidId, serializer, tiles); } catch (IOException e) { e.printStackTrace(); } }
_tileIO.initializeForWrite( TABLE_NAME ); _dataIO.initializeForWrite( TABLE_NAME ); _tileIO.writeTiles(TABLE_NAME, _tileSerializer, AnnotationTile.convertToRaw( tiles ) ); _dataIO.writeData(TABLE_NAME, _dataSerializer, annotations ); List<AnnotationTile> allTiles = AnnotationTile.convertFromRaw(_tileIO.readTiles(TABLE_NAME, _tileSerializer, tileIndices)); List<AnnotationData<?>> allData = _dataIO.readData( TABLE_NAME, _dataSerializer, dataIndices ); AnnotationUtil.printTiles( allTiles ); _tileIO.removeTiles(TABLE_NAME, tileIndices ); _dataIO.removeData(TABLE_NAME, dataIndices ); allTiles = AnnotationTile.convertFromRaw(_tileIO.readTiles(TABLE_NAME, _tileSerializer, tileIndices)); allData = _dataIO.readData( TABLE_NAME, _dataSerializer, dataIndices );
private void showCurrentTile () { if (null == _pyramid) return; if (null == _pyramidId) return; if (null == _pyramidIO) return; if (null == _serializer && null == _bucketSerializer) return; if (null == _levelField.getSelectedItem()) return; if (null == _xField.getSelectedItem()) return; if (null == _yField.getSelectedItem()) return; TileIndex index = new TileIndex((Integer) _levelField.getSelectedItem(), (Integer) _xField.getSelectedItem(), (Integer) _yField.getSelectedItem()); try { List<TileData<Double>> data = null; if (null != _serializer) { data = _pyramidIO.readTiles(_pyramidId, _serializer, Collections.singleton(index)); } else { List<TileData<List<Double>>> rawData = _pyramidIO.readTiles(_pyramidId, _bucketSerializer, Collections.singleton(index)); data = new ArrayList<>(); for (TileData<List<Double>> tile: rawData) { data.add(new DenseTileSliceView<Double>(tile, 0)); } } if (1 == data.size()) { TileData<Double> tile = data.get(0); showTile(tile); } } catch (Exception e) { e.printStackTrace(); } }
_tileIO.writeTiles(BASE_PATH, _tileSerializer, AnnotationTile.convertToRaw(tiles) ); _dataIO.writeData(BASE_PATH, _dataSerializer, annotations ); List<AnnotationTile> allTiles = AnnotationTile.convertFromRaw(_tileIO.readTiles(BASE_PATH, _tileSerializer, tileIndices)); List<AnnotationData<?>> allData = _dataIO.readData( BASE_PATH, _dataSerializer, dataIndices ); AnnotationUtil.printTiles( allTiles ); _tileIO.removeTiles(BASE_PATH, tileIndices ); _dataIO.removeData(BASE_PATH, dataIndices ); allTiles = AnnotationTile.convertFromRaw(_tileIO.readTiles(BASE_PATH, _tileSerializer, tileIndices)); allData = _dataIO.readData( BASE_PATH, _dataSerializer, dataIndices );
@Override public String readMetaData (String pyramidId) throws IOException { return getBasePyramidIO(pyramidId).readMetaData(pyramidId); }
@Override public void initializeForRead (String pyramidId, int width, int height, Properties dataDescription) { if (!_basePyramidIOs.containsKey(pyramidId)) { LOGGER.info("Attempt to initialize unknown pyramid" + pyramidId + "'."); } else { _basePyramidIOs.get(pyramidId).initializeForRead(pyramidId, width, height, dataDescription); } }
protected void writeTilesToIO( String layer, List< AnnotationTile > tiles ) { if ( tiles.size() == 0 ) return; try { LayerConfiguration config = getLayerConfiguration( layer, null ); PyramidIO io = config.produce(PyramidIO.class); TileSerializer<Map<String, List<Pair<String, Long>>>> serializer = SerializationTypeChecker.checkBinClass(config.produce(TileSerializer.class), getRuntimeBinClass(), getRuntimeTypeDescriptor()); String dataId = config.getPropertyValue(LayerConfiguration.DATA_ID); io.writeTiles( dataId, serializer, AnnotationTile.convertToRaw( tiles ) ); } catch ( Exception e ) { throw new IllegalArgumentException( e.getMessage() ); } }
protected void removeTilesFromIO( String layer, List<TileIndex> tiles ) { if ( tiles.size() == 0 ) { return; } try { LayerConfiguration config = getLayerConfiguration( layer, null ); PyramidIO io = config.produce( PyramidIO.class ); String dataId = config.getPropertyValue(LayerConfiguration.DATA_ID); io.removeTiles( dataId, tiles ); } catch ( Exception e ) { throw new IllegalArgumentException( e.getMessage() ); } }
private <T> List<TileData<T>> readAvroTiles (PyramidIO pio, TileSerializer<T> serializer, String pyramidId) { ArrayList<TileIndex> tiles = new ArrayList<TileIndex>(); TileIndex index = new TileIndex(4, 3, 2); tiles.add(index); try { return pio.readTiles(pyramidId, serializer, tiles); } catch (IOException e) { e.printStackTrace(); } return null; }
private <T> void writeAvroTiles (PyramidIO pio, TileSerializer<T> serializer, String pyramidId, ArrayList<TileData<T>> tiles) { try { pio.initializeForWrite(pyramidId); pio.writeTiles(pyramidId, serializer, tiles); } catch (IOException e) { e.printStackTrace(); } }
private PyramidMetaData getCachedMetaData( String layerId, String dataId, PyramidIO pyramidIO ) { try { JSONObject metadata = _metaDataCache.get( layerId ); if ( metadata == null ) { String s = pyramidIO.readMetaData( dataId ); if ( s == null ) { metadata = new JSONObject(); } else { metadata = new JSONObject( s ); } _metaDataCache.put( layerId, metadata ); } return new PyramidMetaData( metadata ); } catch (JSONException e) { LOGGER.error("Metadata file for layer is missing or corrupt: {}", layerId, e); } catch (IOException e) { LOGGER.error("Couldn't read metadata: {}", layerId, e); } return null; }
aio.initializeForRead( dataId ); PyramidIO pio = config.produce( PyramidIO.class ); pio.initializeForRead( dataId, 0, 0, null ); _initializedLayersById.put( layer, true );
private <T> void retrieveAndCopy (String pyramidId, TileSerializer<T> serializer, Iterable<TileIndex> indices) throws IOException { _to.writeTiles(pyramidId, serializer, _from.readTiles(pyramidId, serializer, indices)); }
public void copy (List<TileIndex> rootTiles) throws IOException { _source.initializeForRead(_parameters._sourceId, _parameters._width, _parameters._height, null); _destination.initializeForWrite(_parameters._destinationId); String metaData = _source.readMetaData(_parameters._sourceId); if (null != metaData) _destination.writeMetaData(_parameters._destinationId, metaData); List<TileIndex> toCopy = new ArrayList<>(); for (TileIndex root: rootTiles) { toCopy = copyUp(root, toCopy); toCopy = copyDown(root, toCopy); } doCopy(toCopy); }
private <T> List<TileData<T>> readAvroTiles (PyramidIO pio, TileSerializer<T> serializer, String pyramidId) { ArrayList<TileIndex> tiles = new ArrayList<TileIndex>(); TileIndex index = new TileIndex(4, 3, 2); tiles.add(index); try { return pio.readTiles(pyramidId, serializer, tiles); } catch (IOException e) { e.printStackTrace(); } return null; }
private <T> void writeAvroTiles (PyramidIO pio, TileSerializer<T> serializer, String pyramidId, ArrayList<TileData<T>> tiles) { try { pio.initializeForWrite(pyramidId); pio.writeTiles(pyramidId, serializer, tiles); } catch (IOException e) { e.printStackTrace(); } }
private void updatePyramidType () { _pyramid = null; try { String rawMetaData = _pyramidIO.readMetaData(_pyramidId); PyramidMetaData metaData = new PyramidMetaData(rawMetaData); _pyramid = metaData.getTilePyramid(); } catch (Exception e) { LOGGER.log(Level.WARNING, "Error getting level metadata for " + _pyramidId); } if (null == _pyramid) { _pyramidField.setSelectedIndex(-1); _pyramidDesc.setText(""); } else if (_pyramid instanceof WebMercatorTilePyramid) { _pyramidField.setSelectedItem(PyramidEnum.Geographic); _pyramidDesc.setText(""); } else if (_pyramid instanceof AOITilePyramid) { _pyramidField.setSelectedItem(PyramidEnum.AreaOfInterest); Rectangle2D bounds = _pyramid.getTileBounds(new TileIndex(0, 0, 0)); _pyramidDesc.setText(String.format("bounds: [%.4f, %.4f] to [%.4f, %.4f]", bounds.getMinX(), bounds.getMinY(), bounds.getMaxX(), bounds.getMaxY())); } } private void updateAvailableCoordinates () {