/** * @return the raster reference of the texture * */ public RasterGeoReference getRasterReference() { return raster.getRasterReference(); }
/** * Returns a list with the highest resolution of every level. The list is sorted ascending (from highest to lowest * resolution). * * @return a list of all resolutions */ public List<Double> getResolutions() { List<Double> res = new ArrayList<Double>( resolutions.size() ); for ( AbstractRaster level : resolutions ) { RasterGeoReference renv = level.getRasterReference(); res.add( min( abs( renv.getResolutionX() ), abs( renv.getResolutionY() ) ) ); } return res; }
/** * Returns the best-fitting raster for a given resolution. * * This method tries to return the optimal raster for the requested resolution. It returns the next best resolution * (lower resolution value) if available, otherwise it returns the next raster with a higher resolution value. * * @param res * resolution in world units per pixel * @return raster for resolution or <code>null</code> if no rasters were defined */ public AbstractRaster getRaster( double res ) { Iterator<AbstractRaster> iter = resolutions.iterator(); AbstractRaster prevRaster = null; if ( iter.hasNext() ) { prevRaster = iter.next(); boolean found = false; while ( !found && iter.hasNext() ) { AbstractRaster curRaster = iter.next(); if ( curRaster.getRasterReference().getResolutionX() > res ) { found = true; } else { prevRaster = curRaster; } } } return prevRaster; }
@Override public int compare( AbstractRaster o1, AbstractRaster o2 ) { if ( o1 == null ) { return o2 == null ? 0 : 1; } if ( o2 == null ) { return -1; } double[] orig1 = o1.getRasterReference().getOrigin(); double[] orig2 = o2.getRasterReference().getOrigin(); int result = 0; if ( row ) { result = Double.compare( orig1[1], orig2[1] ); if ( result == 0 ) { result = Double.compare( orig1[0], orig2[0] ); } } else { result = Double.compare( orig1[0], orig2[0] ); if ( result == 0 ) { // Invert for negative resolution. result = -1 * Double.compare( orig1[1], orig2[1] ); } } return result; } }
/** * @param raster * @param writer * @throws IOException */ private static void write( AbstractRaster raster, ImageWriter writer ) throws IOException { write( RasterFactory.imageFromRaster( raster ), raster.getRasterReference(), writer ); }
/** * Returns columns of the raster. * * @return width in pixel */ public int getColumns() { return getRasterReference().getSize( getEnvelope() )[0]; }
/** * Returns rows of the raster. * * @return height in pixel */ public int getRows() { return getRasterReference().getSize( getEnvelope() )[1]; }
/** * Adds an AbstractRaster to the MultiRangedRaster * * @param raster */ public void addRaster( AbstractRaster raster ) { extendEnvelope( raster.getEnvelope() ); extendRasterReference( raster.getRasterReference() ); multiRange.add( raster ); }
/** * Apply the given kernel to the given raster */ public void run() { long time = currentTimeMillis(); Envelope env = originalRaster.getRasterReference().getEnvelope( newTileRect, null ); SimpleRaster procesRaster = originalRaster.getSubRaster( env ).getAsSimpleRaster(); DEMFilter filter = new SmoothingFilter( size, stdevCorr, procesRaster ); SimpleRaster filteredResult = filter.applyFilter(); resultWriter.push( filteredResult ); this.availableFilters.push( this ); synchronized ( lock ) { lock.notifyAll(); } LOG.info( "{}. Filtering of tile took: {} seconds.", Thread.currentThread().getName(), ( Math.round( ( currentTimeMillis() - time ) / 10d ) / 100d ) ); } }
@Override public void setSubRaster( Envelope env, AbstractRaster source ) { AbstractRaster subset = source.getSubRaster( env ); double[] pos = subset.getRasterReference().getOrigin(); setSubRaster( pos[0], pos[1], source ); }
@Override public void setSubRaster( Envelope env, int dstBand, AbstractRaster source ) { AbstractRaster subset = source.getSubRaster( env ); double[] pos = subset.getRasterReference().getOrigin(); setSubRaster( pos[0], pos[1], dstBand, source ); }
/** * Read a texture from a file and load it using the raster api. * * @param raster * the raster api raster. * */ public RasterAPITextureTileProvider( AbstractRaster raster ) { fac = new GeometryFactory(); this.raster = raster; BandType[] bandInfo = this.raster.getRasterDataInfo().bandInfo; hasAlpha = bandInfo.length == 4; for ( int i = 0; !hasAlpha && i < bandInfo.length; ++i ) { if ( bandInfo[i] == BandType.ALPHA ) { this.hasAlpha = true; } } // GriddedBlobTileContainer.create( file, options ) this.res = raster.getRasterReference().getResolutionX(); }
/** * Adds a new tile to the container. * * @param raster * new tile */ public synchronized void addTile( AbstractRaster raster ) { if ( raster != null ) { if ( this.envelope == null ) { this.envelope = raster.getEnvelope(); } else { this.envelope = this.envelope.merge( raster.getEnvelope() ); } if ( this.rasterReference == null ) { this.rasterReference = raster.getRasterReference(); } else { this.rasterReference = RasterGeoReference.merger( this.rasterReference, raster.getRasterReference() ); } if ( this.rdi == null ) { this.rdi = raster.getRasterDataInfo(); } if ( this.resolutionInfo == null ) { this.resolutionInfo = raster.getResolutionInfo(); } tiles.add( raster ); } }
@Override public void write( AbstractRaster raster, File file, RasterIOOptions options ) throws IOException { LOG.debug( "writing " + file + " with JAI" ); String ext = FileUtils.getFileExtension( file ); String format = JAIRasterIOProvider.getJAIFormat( ext ); if ( format != null ) { JAIRasterDataWriter.saveRasterDataToFile( raster.getAsSimpleRaster().getRasterData(), file.getAbsolutePath(), format ); } else { JAIRasterDataWriter.saveRasterDataToFile( raster.getAsSimpleRaster().getRasterData(), file.getAbsolutePath() ); } RasterGeoReference rasterReference = raster.getRasterReference(); WorldFileAccess.writeWorldFile( rasterReference, file ); }
@Override public void write( AbstractRaster raster, File file, RasterIOOptions options ) throws IOException { LOG.debug( "writing " + file + " with ImageIO" ); String format = options != null ? options.get( RasterIOOptions.OPT_FORMAT ) : null; if ( format == null ) { format = FileUtils.getFileExtension( file ); } LOG.debug( "Writing raster with width: {} height: {}", raster.getColumns(), raster.getRows() ); if ( "geotiff".equals( format ) ) { GeoTiffWriter.save( raster, file ); } else { IIORasterDataWriter.saveRasterDataToFile( raster.getAsSimpleRaster().getRasterData(), file, format ); RasterGeoReference rasterReference = raster.getRasterReference(); WorldFileAccess.writeWorldFile( rasterReference, file ); } }
if ( LOG.isDebugEnabled() ) { LOG.debug( "Adding raster intersection:{}, rasterInfo:{}, rasterref: {} ", new Object[] { subsetEnv, r.getRasterDataInfo(), r.getRasterReference() } );
/** * Performs contrast enhancement on all bands of a raster and returns the modified raster. * * @param raster * initial raster * @param contrastEnhancement * @return the enhanced raster */ private AbstractRaster performContrastEnhancement( AbstractRaster raster, ContrastEnhancement contrastEnhancement ) { if ( contrastEnhancement == null ) return raster; LOG.trace( "Enhancing contrast for overall raster..." ); RasterData data = raster.getAsSimpleRaster().getRasterData(), newData = data; RasterDataUtility rasutil = new RasterDataUtility( raster ); rasutil.setContrastEnhancement( contrastEnhancement ); rasutil.precomputeContrastEnhancements( -1, contrastEnhancement ); for ( int band = 0; band < data.getBands(); band++ ) newData = setEnhancedChannelData( newData, rasutil, band, band, contrastEnhancement ); AbstractRaster newRaster = new SimpleRaster( newData, raster.getEnvelope(), raster.getRasterReference(), null ); return newRaster; }
@Override public void setSubRaster( double x, double y, AbstractRaster source ) { RasterGeoReference srcREnv = source.getRasterReference(); RasterGeoReference dstREnv = new RasterGeoReference( srcREnv.getOriginLocation(), srcREnv.getResolutionX(), srcREnv.getResolutionY(), x, y ); Envelope dstEnv = dstREnv.getEnvelope( source.getColumns(), source.getRows(), source.getCoordinateSystem() ); RasterData srcData = source.getAsSimpleRaster().getRasterData(); SimpleRaster movedRaster = new SimpleRaster( srcData, dstEnv, dstREnv, metadata ); setSubRaster( dstEnv, movedRaster ); }
/** * Interpolates the given raster to retrieve a raster with the given width and height. * * @param sourceRaster * the raster to get an interpolation version from * @param dstWidth * the width (columns) of the resulting raster * @param dstHeight * the height (rows) of the resulting raster * @return the interpolated raster */ public AbstractRaster interPolate( AbstractRaster sourceRaster, int dstWidth, int dstHeight ) { SimpleRaster simpleSourceRaster = sourceRaster.getAsSimpleRaster(); RasterData srcData = simpleSourceRaster.getReadOnlyRasterData(); RasterGeoReference srcREnv = simpleSourceRaster.getRasterReference(); // interpolation is needed. Interpolation interpolation = InterpolationFactory.getInterpolation( interpolationType, srcData ); RasterRect rr = new RasterRect( 0, 0, dstWidth, dstHeight ); RasterData dstData = srcData.createCompatibleWritableRasterData( rr, null ); RasterGeoReference dstREnv = RasterGeoReference.create( sourceRaster.getRasterReference().getOriginLocation(), sourceRaster.getEnvelope(), dstWidth, dstHeight ); // use warp to calculate the correct sample positions in the source raster. // the warp is a cubic polynomial function created of 100 points in the dstEnvelope. This function will map // points from the source crs to the target crs very accurate. WarpPolynomial warp = createWarp( dstWidth, dstHeight, srcREnv, dstREnv ); warpTransform( warp, interpolation, dstData ); return new SimpleRaster( dstData, sourceRaster.getEnvelope(), dstREnv, (ResourceMetadata) sourceRaster.getMetadata() ); }
/** * Return the bounding geometry of a raster as a polygon (but is actually a rectangle). * * @param raster * @return bounding polygon */ public static Polygon createPolygonGeometry( AbstractRaster raster ) { ICRS crs = raster.getCoordinateSystem(); GeometryFactory fac = new GeometryFactory(); Envelope env = raster.getEnvelope(); env = raster.getRasterReference().relocateEnvelope( OriginLocation.OUTER, env ); Point pmin = env.getMin(); Point pmax = env.getMax(); Point p1 = fac.createPoint( null, pmin.get0(), pmin.get1(), crs ); Point p3 = fac.createPoint( null, pmax.get0(), pmax.get1(), crs ); Point p2 = fac.createPoint( null, p1.get0(), p3.get1(), crs ); Point p4 = fac.createPoint( null, p3.get0(), p1.get1(), crs ); Point p5 = fac.createPoint( null, p1.get0(), p1.get1(), crs ); Point[] points = { p1, p2, p3, p4, p5 }; // (asList(points)); LinearRing ring = fac.createLinearRing( null, crs, new PointsList( asList( points ) ) ); Polygon poly = fac.createPolygon( null, crs, ring, null ); return poly; }