Application: gvSIG desktop » gvSIG raster

package org.gvsig.raster.lizardtech.io;

import java.awt.geom.AffineTransform;

import java.awt.geom.Point2D;

import java.awt.image.BufferedImage;

import java.io.File;

import java.net.URI;

import java.net.URISyntaxException;

import es.gva.cit.jmrsid.MrSIDException;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.gvsig.fmap.dal.DALFileLocator;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataStore;

import org.gvsig.fmap.dal.coverage.RasterLocator;

import org.gvsig.fmap.dal.coverage.dataset.Buffer;

import org.gvsig.fmap.dal.coverage.datastruct.BandList;

import org.gvsig.fmap.dal.coverage.datastruct.Extent;

import org.gvsig.fmap.dal.coverage.exception.BandAccessException;

import org.gvsig.fmap.dal.coverage.exception.FileNotOpenException;

import org.gvsig.fmap.dal.coverage.exception.InvalidSetViewException;

import org.gvsig.fmap.dal.coverage.exception.InvalidSourceException;

import org.gvsig.fmap.dal.coverage.exception.NotSupportedExtensionException;

import org.gvsig.fmap.dal.coverage.exception.ParsingException;

import org.gvsig.fmap.dal.coverage.exception.ProcessInterruptedException;

import org.gvsig.fmap.dal.coverage.exception.RasterDriverException;

import org.gvsig.fmap.dal.exception.OpenException;

import org.gvsig.fmap.dal.spi.DataManagerProviderServices;

import org.gvsig.fmap.dal.spi.DataStoreProviderServices;

import org.gvsig.metadata.MetadataLocator;

import org.gvsig.raster.cache.tile.provider.TileServer;

import org.gvsig.raster.impl.buffer.SpiRasterQuery;

import org.gvsig.raster.impl.datastruct.ExtentImpl;

import org.gvsig.raster.impl.process.RasterTask;

import org.gvsig.raster.impl.process.RasterTaskQueue;

import org.gvsig.raster.impl.provider.AbstractRasterProvider;

import org.gvsig.raster.impl.provider.RasterProvider;

import org.gvsig.raster.impl.provider.tile.FileTileServer;

import org.gvsig.raster.impl.store.AbstractRasterDataParameters;

import org.gvsig.raster.impl.store.DefaultRasterStore;

import org.gvsig.raster.impl.store.DefaultStoreFactory;

import org.gvsig.raster.impl.store.properties.DataStoreColorInterpretation;

import org.gvsig.raster.impl.store.properties.DataStoreTransparency;

import org.gvsig.tools.ToolsLocator;

/**

 * Clase encargada del acceso a los datos y repintado de imagenes MrSID. Estos

 * son registrados con la extensi?n sid

 *

 * @version 15/05/2008

 * @author Nacho Brodin (nachobrodin@gmail.com)

 */

public class LizardTechProvider extends AbstractRasterProvider {

    private static final Logger logger = LoggerFactory.getLogger(LizardTechProvider.class);

        public static String                 NAME                     = "LizardTech Store";

        public static String                 DESCRIPTION              = "LizardTech Raster file";

        public static final String           METADATA_DEFINITION_NAME = "LizardTechStore";

        protected LizardTechNative           lztNative                     = null;

        private Extent                       viewRequest              = null;

        private DataStoreColorInterpretation colorInterpr             = null;

        protected DataStoreTransparency      fileTransparency         = null;

        private boolean                      open                     = false;

        protected static String[]            formatList               = null;

        public static void register() {

                RasterLocator.getManager().getProviderServices().registerFileProvidersTiled(LizardTechProvider.class);

                registerFormats();

                DataManagerProviderServices dataman = (DataManagerProviderServices) DALLocator.getDataManager();

                if (dataman != null && !dataman.getStoreProviders().contains(NAME)) {

                        dataman.registerStoreProvider(NAME,

                                        LizardTechProvider.class, LizardTechDataParameters.class);

                }

                if(DALFileLocator.getFilesystemServerExplorerManager() != null)

                        DALFileLocator.getFilesystemServerExplorerManager().registerProvider(

                                        NAME, DESCRIPTION,

                                        LizardTechFilesystemServerExplorer.class);

                dataman.registerStoreFactory(NAME, DefaultStoreFactory.class);

        }

        private static void registerFormats() {

                formatList      = new String[] {"sid"};

                for (int i = 0; i < formatList.length; i++)

                        RasterLocator.getManager().getProviderServices().addFormat(formatList[i], LizardTechProvider.class);

        }

        public String[] getFormatList() {

                return formatList;

        }

        /**

         * Returns true if the extension is supported and false if doesn't

         * @param ext

         * @return

         */

        public boolean isExtensionSupported(String ext) {

                if(ext.indexOf(".") != -1)

                        ext = ext.substring(ext.lastIndexOf(".") + 1, ext.length());

                for (int i = 0; i < formatList.length; i++) {

                        if(formatList[i].compareTo(ext) == 0)

                                return true;

                }

                return false;

        }

        /**

         * Mandatory constructor to instantiate an empty provider

         */

        public LizardTechProvider() {

        }

        /**

         * Constructor. Abre el dataset.

         * @param proj Proyecci?n

         * @param fName Nombre del fichero ecw

         * @throws NotSupportedExtensionException

         * @throws OpenException

     * @deprecated use {@link #LizardTechProvider(URI)}, this constructor will be removed in gvSIG 2.5

         */

        public LizardTechProvider(String params) throws NotSupportedExtensionException, OpenException {

                super(params);

        logger.info("Deprecated use of LizardTechProvider constructor");

                if(params instanceof String) {

                        LizardTechDataParameters p = new LizardTechDataParameters();

            URI uriObj;

            try {

                uriObj = new URI((String)params);

            } catch (URISyntaxException e) {

                throw new OpenException("Can't create uri from "+(String)params, e);

            }

            p.setURI(uriObj);

                        super.init(p, null, ToolsLocator.getDynObjectManager()

                                        .createDynObject(

                                                        MetadataLocator.getMetadataManager().getDefinition(

                                                                        DataStore.METADATA_DEFINITION_NAME)));

                        init(p, null);

                }

        }

    /**

     * Constructor. Abre el dataset.

     * @param proj Proyecci?n

     * @param fName Nombre del fichero ecw

     * @throws NotSupportedExtensionException

     */

    public LizardTechProvider(URI uri) throws NotSupportedExtensionException {

        super(uri);

        LizardTechDataParameters p = new LizardTechDataParameters();

        p.setURI(uri);

        super.init(

            p,

            null,

            ToolsLocator.getDynObjectManager().createDynObject(

                MetadataLocator.getMetadataManager().getDefinition(DataStore.METADATA_DEFINITION_NAME)));

        init(p, null);

    }

        public LizardTechProvider(LizardTechDataParameters params,

                        DataStoreProviderServices storeServices) throws NotSupportedExtensionException {

                super(params, storeServices, ToolsLocator.getDynObjectManager()

                                .createDynObject(

                                                MetadataLocator.getMetadataManager().getDefinition(

                                                                DataStore.METADATA_DEFINITION_NAME)));

                init(params, storeServices);

        }

        /**

         * Contructor. Abre el fichero mrsid

         * @param proj Proyecci?n

         * @param fName Nombre del fichero mrsid

         */

        public void init(AbstractRasterDataParameters params,

                        DataStoreProviderServices storeServices) throws NotSupportedExtensionException {

                setParam(storeServices, params);

                try {

                        lztNative = new LizardTechNative(params.getURI().getPath());

                        load();

                        bandCount = lztNative.nbands;

                        int[] dt = new int[bandCount];

                        for (int i = 0; i < dt.length; i++)

                                dt[i] = Buffer.TYPE_BYTE;

                        setDataType(dt);

                        super.init();

                        try {

                                loadFromRmf(getRmfBlocksManager());

                        } catch (ParsingException e) {

                                // No lee desde rmf

                        }

                } catch (Exception e) {

                        System.out.println("Error en constructor de MrSID");

                        e.printStackTrace();

                        lztNative = null;

                }

                open = true;

        }

        public RasterProvider load() {

                ownTransformation = lztNative.getOwnTransformation();

                externalTransformation = (AffineTransform) ownTransformation.clone();

                return this;

        }

        public boolean isOpen() {

                return open;

        }

        public void close() {

                if (lztNative != null) {

                        lztNative.close();

                        lztNative = null;

                }

                open = false;

        }

        public void setView(Extent e) {

                viewRequest = new ExtentImpl(e);

        }

        public Extent getView() {

                return viewRequest;

        }

        public double getWidth() {

                return lztNative.width;

        }

        public double getHeight() {

                return lztNative.height;

        }

        /**

         * Asigna al objeto Image los valores con los dato de la imagen contenidos en

         * el vector de enteros.

         * @param image imagen con los datos actuales

         * @param startX inicio de la posici?n en X dentro de la imagen

         * @param startY inicio de la posici?n en X dentro de la imagen

         * @param w Ancho de la imagen

         * @param h Alto de la imagen

         * @param rgbArray vector que contiene la banda que se va a sustituir

         * @param offset desplazamiento

         * @param scansize tama?o de imagen recorrida por cada p

         */

        protected void setRGBLine(BufferedImage image, int startX, int startY, int w, int h,

                                                                                                                int[] rgbArray, int offset, int scansize) {

                image.setRGB(startX, startY, w, h, rgbArray, offset, scansize);

        }

        public Object getData(int x, int y, int band) throws InvalidSetViewException, FileNotOpenException, RasterDriverException {

                if (lztNative != null) {

                        if (x < 0 || y < 0 || x >= lztNative.width || y >= lztNative.height)

                                throw new InvalidSetViewException("Request out of grid");

                        Object[] data = lztNative.getData(x, y);

                        return data[band];

                }

                throw new FileNotOpenException("MrSIDNative not exist");

        }

        public int getBlockSize() {

                return lztNative.blocksize;

        }

        /**

         * Informa de si el driver ha supersampleado en el ?ltimo dibujado. Es el

         * driver el que colocar? el valor de esta variable cada vez que dibuja.

         * @return true si se ha supersampleado y false si no se ha hecho.

         */

        public boolean isSupersampling() {

                return lztNative.isSupersampling;

        }

        @Override

        public void loadBuffer(SpiRasterQuery query)

                        throws ProcessInterruptedException, RasterDriverException {

                setView(query.getAdjustedRequestBoundingBox());

                int width = query.getAdjustedBufWidth();

                int height = query.getAdjustedBufHeight();

                lztNative.setView(viewRequest.getULX(), viewRequest.getULY(), viewRequest.getLRX(), viewRequest.getLRY(), width, height);

                int[] pRGBArray = new int[width * height];

                try {

                        RasterTask task = RasterTaskQueue.get(Thread.currentThread().getId() + "");

                        lztNative.readScene(pRGBArray, task);

                        loadBuffer(height,

                                        width,

                                        query.getBandList(),

                                        query.getBufferForProviders(),

                                        pRGBArray);

                } catch (MrSIDException e) {

                        throw new RasterDriverException("Error reading data");

                }

        }

//        private void loadCachedBuffer(        Buffer buf,

//                                                                        Extent inputWindow,

//                                                                        RasterTask task,

//                                                                        int[] pRGBArray,

//                                                                        BandList bandList) throws ProcessInterruptedException, MrSIDException {

//                if(buf.isCached()) {

//                        Point2D blockHeightWC = rasterToWorld(new Point2D.Double(buf.getBlockHeight(), buf.getBlockHeight()));

//                        int nBlocks = (int)(inputWindow.height() / blockHeightWC.getX());

//                        double lastblockWC = inputWindow.height() - (nBlocks * blockHeightWC.getX());

//                        int lastBlock = buf.getHeight() - (nBlocks * buf.getBlockHeight());

//                        if(lastblockWC > 0)

//                                nBlocks ++;

//                        double init = inputWindow.getULY();

//                        Extent ext = null;

//                        for (int i = 0; i < nBlocks; i++) {

//                                if(lastblockWC > 0 && i == (nBlocks - 1)) {

//                                        ext = RasterLocator.getManager().getDataStructFactory().createExtent(

//                                                        inputWindow.getULX(),

//                                                        init,

//                                                        inputWindow.getLRX(),

//                                                        lastblockWC);

//                                        file.setView(ext.getULX(), ext.getULY(), ext.getLRX(), ext.getLRY(), buf.getWidth(), buf.getBlockHeight());

//                                        file.readScene(pRGBArray, task);

//                                        loadPartialBuffer(new int[]{0, i * buf.getBlockHeight(), buf.getWidth(), buf.getHeight() },

//                                                                        bandList,

//                                                                        buf,

//                                                                        pRGBArray,

//                                                                        buf.getWidth());

//                                } else {

//                                        ext = RasterLocator.getManager().getDataStructFactory().createExtent(

//                                                        inputWindow.getULX(),

//                                                        init,

//                                                        inputWindow.getLRX(),

//                                                        init - blockHeightWC.getX());

//                                        file.setView(ext.getULX(), ext.getULY(), ext.getLRX(), ext.getLRY(), buf.getWidth(), lastBlock);

//                                        file.readScene(pRGBArray, task);

//                                        loadPartialBuffer(new int[]{0, i * buf.getBlockHeight(), buf.getWidth(), i * buf.getBlockHeight() + buf.getBlockHeight() },

//                                                        bandList,

//                                                        buf,

//                                                        pRGBArray,

//                                                        buf.getWidth());

//                                        init += buf.getBlockHeight();

//                                }

//                        }

//                } else {

//                        file.setView(inputWindow.getULX(), inputWindow.getULY(), inputWindow.getLRX(), inputWindow.getLRY(), buf.getWidth(), buf.getHeight());

//                        file.readScene(pRGBArray, task);

//                        loadBuffer(buf.getWidth(), buf.getHeight(), bandList, buf, pRGBArray);

//                }

//        }

//

//        private void loadPartialBuffer(int[] stepBuffer,

//                        BandList bandList,

//                        Buffer rasterBuf,

//                        int[] pRGBArray,

//                        int bufWidth) throws ProcessInterruptedException {

//                RasterTask task = RasterTaskQueue.get(Thread.currentThread().getId() + "");

//                int[] drawableBandsR = bandList.getBufferBandToDraw(getURIOfFirstProvider(), 0);

//                int[] drawableBandsG = bandList.getBufferBandToDraw(getURIOfFirstProvider(), 1);

//                int[] drawableBandsB = bandList.getBufferBandToDraw(getURIOfFirstProvider(), 2);

//                int element = 0;

//                int rowSrc = 0;

//

//                for (int row = stepBuffer[1]; row < stepBuffer[3]; row++) {

//                        int colSrc = 0;

//                        for (int col = stepBuffer[0]; col < stepBuffer[2]; col++) {

//                                element = pRGBArray[(rowSrc * bufWidth) + colSrc];

//                                if(drawableBandsR != null) {

//                                        for (int i = 0; i < drawableBandsR.length; i++) {

//                                                if(drawableBandsR[i] >= 0 && drawableBandsR[i] < rasterBuf.getBandCount())

//                                                        rasterBuf.setElem(row, col, drawableBandsR[i], (byte) ((element & 0x00ff0000) >> 16));

//                                        }

//                                }

//                                if(drawableBandsG != null) {

//                                        for (int i = 0; i < drawableBandsG.length; i++) {

//                                                if(drawableBandsG[i] >= 0 && drawableBandsG[i] < rasterBuf.getBandCount())

//                                                        rasterBuf.setElem(row, col, drawableBandsG[i], (byte) ((element & 0x0000ff00) >> 8));

//                                        }

//                                }

//                                if(drawableBandsB != null) {

//                                        for (int i = 0; i < drawableBandsB.length; i++) {

//                                                if(drawableBandsB[i] >= 0 && drawableBandsB[i] < rasterBuf.getBandCount())

//                                                        rasterBuf.setElem(row, col, drawableBandsB[i], (byte) (element & 0x000000ff));

//                                        }

//                                }

//                                colSrc ++;

//                        }

//                        if (task.getEvent() != null)

//                                task.manageEvent(task.getEvent());

//                        rowSrc ++;

//                }

//        }

        private void loadBuffer(int h, int w, BandList bandList, Buffer rasterBuf, int[] pRGBArray) throws ProcessInterruptedException {

                RasterTask task = RasterTaskQueue.get(Thread.currentThread().getId() + "");

                int[] drawableBandsR = bandList.getBufferBandToDraw(getURIOfFirstProvider().getPath(), 0);

                int[] drawableBandsG = bandList.getBufferBandToDraw(getURIOfFirstProvider().getPath(), 1);

                int[] drawableBandsB = bandList.getBufferBandToDraw(getURIOfFirstProvider().getPath(), 2);

                int element = 0;

                for (int row = 0; row < h; row++) {

                        for (int col = 0; col < w; col++) {

                                element = pRGBArray[(row * w) + col];

                                if(drawableBandsR != null) {

                                        for (int i = 0; i < drawableBandsR.length; i++) {

                                                if(drawableBandsR[i] >= 0 && drawableBandsR[i] < rasterBuf.getBandCount())

                                                        rasterBuf.setElem(row, col, drawableBandsR[i], (byte) ((element & 0x00ff0000) >> 16));

                                        }

                                }

                                if(drawableBandsG != null) {

                                        for (int i = 0; i < drawableBandsG.length; i++) {

                                                if(drawableBandsG[i] >= 0 && drawableBandsG[i] < rasterBuf.getBandCount())

                                                        rasterBuf.setElem(row, col, drawableBandsG[i], (byte) ((element & 0x0000ff00) >> 8));

                                        }

                                }

                                if(drawableBandsB != null) {

                                        for (int i = 0; i < drawableBandsB.length; i++) {

                                                if(drawableBandsB[i] >= 0 && drawableBandsB[i] < rasterBuf.getBandCount())

                                                        rasterBuf.setElem(row, col, drawableBandsB[i], (byte) (element & 0x000000ff));

                                        }

                                }

                        }

                        if (task.getEvent() != null)

                                task.manageEvent(task.getEvent());

                }

        }

        public Object readBlock(int pos, int blockHeight, double scale) throws InvalidSetViewException, FileNotOpenException, RasterDriverException, ProcessInterruptedException {

                RasterTask task = RasterTaskQueue.get(Thread.currentThread().getId() + "");

                if (pos < 0)

                        throw new InvalidSetViewException("Request out of grid");

                if ((pos + blockHeight) > lztNative.height)

                        blockHeight = Math.abs(lztNative.height - pos);

                Point2D begin = rasterToWorld(new Point2D.Double(0, pos));

                Point2D end = rasterToWorld(new Point2D.Double(lztNative.width, pos + blockHeight));

                int w = lztNative.width;

                lztNative.setView(begin.getX(), begin.getY(), end.getX(), end.getY(), w, blockHeight);

                int[] pRGBArray = new int[lztNative.width * blockHeight];

                try {

                        lztNative.readScene(pRGBArray, task);

                        byte[][][] buf = new byte[3][blockHeight][w];

                        for (int row = 0; row < blockHeight; row++) {

                                for (int col = 0; col < w; col++) {

                                        buf[0][row][col] = (byte) ((pRGBArray[(row * w) + col] & 0x00ff0000) >> 16);

                                        buf[1][row][col] = (byte) ((pRGBArray[(row * w) + col] & 0x0000ff00) >> 8);

                                        buf[2][row][col] = (byte) (pRGBArray[(row * w) + col] & 0x000000ff);

                                }

                                if (task.getEvent() != null)

                                        task.manageEvent(task.getEvent());

                        }

                        return buf;

                } catch (MrSIDException e) {

                        throw new RasterDriverException("Error reading data");

                }

        }

        /**

         * Read a line from the file

         * @param line

         * @param band

         * @return

         * @throws InvalidSetViewException

         * @throws FileNotOpenException

         * @throws RasterDriverException

         * @Deprecated This operation is deprecated because is not useful and in the future

         * it will not be maintained. The abstract operation has dissapear

         */

        public Object readCompleteLine(int line, int band)

                                        throws InvalidSetViewException, FileNotOpenException, RasterDriverException {

                RasterTask task = RasterTaskQueue.get(Thread.currentThread().getId() + "");

                if (line > this.getHeight() || band > this.getBandCount())

                        throw new InvalidSetViewException("Request out of grid");

                try {

                        Extent extent = getExtent();

                        Point2D pt = rasterToWorld(new Point2D.Double(extent.minX(), line));

                        lztNative.setView(extent.minX(), pt.getY(), extent.maxX(), pt.getY(), (int)getWidth(), 1);

                        int[] pRGBArray = new int[(int)getWidth()];

                        lztNative.readScene(pRGBArray, task);

                        return pRGBArray;

                } catch (MrSIDException e) {

                        throw new RasterDriverException("Error reading data from MrSID library");

                } catch (ProcessInterruptedException e) {

                        // El proceso que debe ser interrumpido es el que llama a readLine.

                }

                return null;

        }

        public DataStoreTransparency getTransparency() {

                if (fileTransparency == null)

                        fileTransparency = new DataStoreTransparency(getColorInterpretation());

                return fileTransparency;

        }

        public DataStoreColorInterpretation getColorInterpretation() {

                if(colorInterpr == null) {

                        colorInterpr = new DataStoreColorInterpretation();

                        colorInterpr.initColorInterpretation(getBandCount());

                        if(getBandCount() == 1)

                                colorInterpr = DataStoreColorInterpretation.createGrayInterpretation();

                        if(getBandCount() == 3) {

                                colorInterpr =  DataStoreColorInterpretation.createRGBInterpretation();

                        }

                        if(getBandCount() >= 4) {

                                colorInterpr = DataStoreColorInterpretation.createRGBAInterpretation();

                        }

                }

                return colorInterpr;

        }

        public String getWktProjection() {

                // System.err.println("======>" + file);

                return null;

        }

        public void setAffineTransform(AffineTransform t) {

                super.setAffineTransform(t);

                lztNative.setExternalTransform(t);

        }

        public int getOverviewCount(int band) throws BandAccessException, RasterDriverException {

                if (band >= getBandCount())

                        throw new BandAccessException("Wrong band");

                try {

                        return lztNative.getNumLevels();

                } catch (MrSIDException e) {

                        throw new RasterDriverException("");

                }

        }

        public int getOverviewWidth(int band, int overview) throws BandAccessException, RasterDriverException {

                if (band >= getBandCount())

                        throw new BandAccessException("Wrong band");

                return 0;

        }

        public int getOverviewHeight(int band, int overview) throws BandAccessException, RasterDriverException {

                if (band >= getBandCount())

                        throw new BandAccessException("Wrong band");

                return 0;

        }

        public boolean isOverviewsSupported() {

                // No podemos escribir por lo que no podemos informar de que soporta overviews aunque el formato si lo haga.

                return false;

        }

        public String getProviderName() {

                return NAME;

        }

        public void setStatus(RasterProvider provider) {

                if(provider instanceof LizardTechProvider) {

                        //Not implemented yet

                }

        }

        public TileServer getTileServer() {

                if(tileServer == null) {

                        DefaultRasterStore store = new DefaultRasterStore();

                        store.setProvider(this);

                        tileServer = new FileTileServer(store);

                }

                return tileServer;

        }

    public void addFile(File file) throws InvalidSourceException {

        // Do nothing

    }

    public void removeFile(File file) {

        // Do nothing

    }

}