import java.io.File;
import java.util.Collection;
import java.awt.Rectangle;
import java.awt.image.Raster;
import java.awt.image.RenderedImage;
import java.awt.image.ImagingOpException;
import org.apache.sis.image.ImageProcessor;
import org.apache.sis.storage.Resource;
import org.apache.sis.storage.Aggregate;
import org.apache.sis.storage.DataStore;
import org.apache.sis.storage.DataStores;
import org.apache.sis.storage.DataStoreException;
import org.apache.sis.storage.GridCoverageResource;
import org.apache.sis.storage.RasterLoadingStrategy;
import org.apache.sis.coverage.grid.GridCoverage;

public class RasterBiggerThanMemory {
    /**
     * Demo entry point.
     *
     * @param  args  ignored.
     * @throws DataStoreException if an error occurred while reading the raster.
     * @throws ImagingOpException unchecked exception thrown if an error occurred while loading a tile.
     */
    public static void main(String[] args) throws DataStoreException {
        try (DataStore store = DataStores.open(new File("TM250m.tiff"))) {
            Collection<? extends Resource> allImages = ((Aggregate) store).components();
            GridCoverageResource firstImage = (GridCoverageResource) allImages.iterator().next();
            /*
             * Following line requests to load data at `RenderedImage.getTile(…)` invocation time.
             * This is the key line of code for handling rasters larger than memory, but is effective
             * only if the file is tiled as in, for example, Cloud Optimized GeoTIFF (COG) convention.
             * Without this line, the default is to load all data at `GridCoverageResource.read(…)`
             * invocation time.
             */
            firstImage.setLoadingStrategy(RasterLoadingStrategy.AT_GET_TILE_TIME);
            GridCoverage data = firstImage.read(null, null);
            printPixelValue(data, false);
            /*
             * Contrarily to other examples, the `GridCoverage` fetched in deferred reading mode
             * can NOT be used outside this `try` block, because the `DataStore` must be open.
             */
        }
    }

    /**
     * Prints the value of an arbitrary pixel.
     *
     * @param data      the data from which to get sample values.
     * @param prefetch  whether to load some pixels in advance.
     */
    private static void printPixelValue(GridCoverage data, boolean prefetch) {
        RenderedImage image = data.render(null);
        System.out.printf("The image has %d × %d tiles.%n", image.getNumXTiles(), image.getNumYTiles());
        /*
         * If we know in advance which tiles will be requested, specifying them in advance allows
         * the GeoTIFF reader to use a better strategy than loading the tiles in random order.
         * This step is optional.
         */
        if (prefetch) {
            var processor = new ImageProcessor();
            image = processor.prefetch(image, new Rectangle(90000, 50000, 1000, 1000));
        }
        /*
         * Get an arbitrary tile, then get an arbitrary sample value in an arbitrary band (the blue channel).
         * This example handles the tiles directly for demonstration purposes, but it could be simplified
         * by using `PixelIterator` instead.
         */
        Raster tile = image.getTile(130, 80);               // This is where tile loading actually happen.
        System.out.printf("Got a tile starting at coordinates %d, %d.%n", tile.getMinX(), tile.getMinY());
        System.out.printf("A sample value in the arbitrary tile: %d%n", tile.getSample(93710, 57680, 2));
    }
}