Application: gvSIG desktop » gvSIG raster

/* gvSIG. Desktop Geographic Information System.

 *

 * Copyright ? 2007-2016 gvSIG Association

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License

 * as published by the Free Software Foundation; either version 2

 * of the License, or (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,

 * MA  02110-1301, USA.

 *

 * For any additional information, do not hesitate to contact us

 * at info AT gvsig.com, or visit our website www.gvsig.com.

 */

package org.gvsig.fmap.dal.file.jimi;

import java.awt.Canvas;

import java.awt.Image;

import java.awt.MediaTracker;

import java.awt.image.ColorModel;

import java.awt.image.ImageConsumer;

import java.awt.image.ImageProducer;

import java.io.ByteArrayInputStream;

import java.io.File;

import java.util.ArrayList;

import java.util.Hashtable;

import java.util.List;

import java.util.Map;

import org.apache.commons.io.FileUtils;

import org.apache.commons.io.FilenameUtils;

import org.cresques.cts.IProjection;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataManager;

import org.gvsig.fmap.dal.DataServerExplorer;

import org.gvsig.fmap.dal.DataStore;

import org.gvsig.fmap.dal.DataStoreNotification;

import org.gvsig.fmap.dal.FileHelper;

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

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

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

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

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

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

import org.gvsig.fmap.dal.raster.api.BandAttributeDescriptor;

import org.gvsig.fmap.dal.raster.api.BandDescriptor;

import org.gvsig.fmap.dal.raster.api.BandQuery;

import org.gvsig.fmap.dal.raster.api.RasterQuery;

import org.gvsig.fmap.dal.raster.spi.AbstractRasterStoreProvider;

import org.gvsig.fmap.dal.resource.ResourceAction;

import org.gvsig.fmap.dal.resource.exception.AccessResourceException;

import org.gvsig.fmap.dal.resource.file.FileResource;

import org.gvsig.fmap.dal.resource.spi.ResourceConsumer;

import org.gvsig.fmap.dal.resource.spi.ResourceProvider;

import org.gvsig.fmap.dal.serverexplorer.filesystem.FilesystemServerExplorer;

import org.gvsig.fmap.dal.serverexplorer.filesystem.FilesystemServerExplorerParameters;

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

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.GeometryLocator;

import org.gvsig.fmap.geom.exception.CreateEnvelopeException;

import org.gvsig.fmap.geom.primitive.Envelope;

import org.gvsig.metadata.MetadataLocator;

import org.gvsig.metadata.MetadataManager;

import org.gvsig.metadata.exceptions.MetadataException;

import org.gvsig.raster.lib.buffer.api.BandInfo;

import org.gvsig.raster.lib.buffer.api.Buffer;

import org.gvsig.raster.lib.buffer.api.BufferLocator;

import org.gvsig.raster.lib.buffer.api.BufferManager;

import org.gvsig.raster.lib.buffer.api.NoData;

import org.gvsig.raster.lib.buffer.api.PageManager;

import org.gvsig.raster.lib.buffer.api.exceptions.BufferException;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dynobject.DynObject;

import org.gvsig.tools.dynobject.exception.DynFieldNotFoundException;

import org.gvsig.tools.exception.BaseException;

import org.gvsig.tools.locator.LocatorException;

import org.gvsig.tools.task.SimpleTaskStatus;

import org.gvsig.tools.task.TaskStatusManager;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import com.sun.jimi.core.Jimi;

import com.sun.jimi.core.JimiReader;

import com.sun.jimi.core.raster.JimiRasterImage;

import com.sun.jimi.core.util.ProgressListener;

/**

 * Provider for JIMI files

 * @author dmartinezizquierdo

 *

 */

public class JimiRasterStoreProvider extends AbstractRasterStoreProvider implements

ResourceConsumer{

    private static final Logger logger =

        LoggerFactory.getLogger(JimiRasterStoreProvider.class);

    public static String NAME = "JIMI";

    public static String DESCRIPTION = "JIMI file";

    public static final String METADATA_DEFINITION_NAME = NAME;

    private ResourceProvider resource;

    private final SimpleTaskStatus taskStatus;

    private MemoryImage image = null;

    private Envelope envelope = null;

    private IProjection projection= null;

    private Canvas waitComponent = null;

    protected static void registerMetadataDefinition()

        throws MetadataException {

        MetadataManager manager = MetadataLocator.getMetadataManager();

        if (manager.getDefinition(METADATA_DEFINITION_NAME) == null) {

            manager.addDefinition(METADATA_DEFINITION_NAME,

                JimiRasterStoreProviderParameters.class

                    .getResourceAsStream("JimiMetadata.xml"),

                JimiRasterStoreProviderParameters.class.getClassLoader());

        }

    }

    public JimiRasterStoreProvider(JimiRasterStoreProviderParameters params,

        DataStoreProviderServices storeServices)

        throws InitializeException {

        super(

                params,

                storeServices,

                FileHelper.newMetadataContainer(METADATA_DEFINITION_NAME)

        );

        TaskStatusManager manager = ToolsLocator.getTaskStatusManager();

        this.taskStatus = manager.createDefaultSimpleTaskStatus("Jimi");

        this.init(params, storeServices);

    }

    protected JimiRasterStoreProvider(JimiRasterStoreProviderParameters params,

            DataStoreProviderServices storeServices, DynObject metadata)

            throws InitializeException {

        super(params, storeServices, metadata);

        TaskStatusManager manager = ToolsLocator.getTaskStatusManager();

        this.taskStatus = manager.createDefaultSimpleTaskStatus("Jimi");

        this.init(params, storeServices);

    }

    protected void init(JimiRasterStoreProviderParameters params,

        DataStoreProviderServices storeServices) throws InitializeException {

        if (params == null) {

            throw new InitializeException(

                new NullPointerException("params is null"));

        }

        File file = getJimiParameters().getFile();

        if (file == null) {

            throw new InitializeException(

                new NullPointerException("Jimi file is null"));

        }

        this.projection=params.getCRS();

        resource = this.createResource(

            FileResource.NAME,

            new Object[] { file.getAbsolutePath() }

        );

        resource.addConsumer(this);

    }

    private JimiRasterStoreProviderParameters getJimiParameters() {

        return (JimiRasterStoreProviderParameters) this.getParameters();

    }

    @Override

    public BandDescriptor getBandDescriptor(int band) {

        if(band > this.getBands()){

            throw new IllegalArgumentException("Invalid band");

        }

        return getStoreServices().createBandDescriptor(band,

            new ArrayList<BandAttributeDescriptor>());

    }

    @Override

    public int getBands() {

        return image.bands;

    }

    @Override

    public Buffer createBuffer(RasterQuery rasterQuery) throws BufferException {

        BufferManager bufferManager = BufferLocator.getBufferManager();

        List<BandQuery> bands = rasterQuery.getBands();

        int[] bandDataTypes = new int[bands.size()];

        NoData[] bandNoData = new NoData[bands.size()];

        List<PageManager> pageManagers = new ArrayList<PageManager>();

        for (BandQuery bandQuery : bands) {

            int band = bandQuery.getBand();

            bandDataTypes[band] = image.dataType;

            bandNoData[band] = null;

            pageManagers.add(new MemoryImageBandPageManager(image, band));

        }

        Buffer buffer =

            bufferManager.createBuffer(image.rows, image.columns, bandDataTypes, bandNoData,

                projection, envelope, pageManagers);

        return buffer;

    }

    @Override

    public BandInfo getBandInfo(int band) {

        return null;

    }

    @Override

    public DataServerExplorer getExplorer()

        throws ReadException, ValidateDataParametersException {

        DataManager manager = DALLocator.getDataManager();

        FilesystemServerExplorerParameters params;

        try {

            params = (FilesystemServerExplorerParameters) manager

            .createServerExplorerParameters(FilesystemServerExplorer.NAME);

            params.setRoot(this.getJimiParameters().getFile().getParent());

            return manager.openServerExplorer(FilesystemServerExplorer.NAME,params);

        } catch (DataException e) {

            throw new ReadException(this.getProviderName(), e);

        } catch (ValidateDataParametersException e) {

            throw new ReadException(this.getProviderName(), e);

        }

    }

    public void open() throws OpenException {

        if (this.image != null) {

            return;

        }

        openEver();

    }

    private void openEver() throws OpenException {

        try {

            getResource().execute(new ResourceAction() {

                public Object run() throws Exception {

                    JimiReader reader = null;

                    try {

                        File file = (File) resource.get();

                        resource.notifyOpen();

                        reader = Jimi.createJimiReader(file.toURI().toURL(),Jimi.SYNCHRONOUS);

                        reader.setProgressListener(new ProgressListener() {

                            @Override

                            public void setStarted() {

                                taskStatus.add();

                                taskStatus.setRangeOfValues(0, 100);

                            }

                            @Override

                            public void setProgressLevel(int arg0) {

                                taskStatus.setCurValue(arg0);

                            }

                            @Override

                            public void setFinished() {

                                taskStatus.terminate();

                            }

                            @Override

                            public void setAbort(String arg0) {

                                taskStatus.abort();

                            }

                            @Override

                            public void setAbort() {

                                taskStatus.abort();

                            }

                        });

                        ByteArrayInputStream is = new ByteArrayInputStream(FileUtils.readFileToByteArray(file));

                        JimiRasterImage jimiRasterImage = Jimi.getRasterImage(is, Jimi.SYNCHRONOUS);

                        NewImageConsumer imageConsumer = new NewImageConsumer();

                        imageConsumer.addImage(jimiRasterImage);

                        imageConsumer.waitFor();

                        image = new MemoryImage(jimiRasterImage);

                        if (getJimiParameters().getWldParams()!=null){

                            envelope=createWLDEnvelope(getJimiParameters().getWldParams());

                        }else{

                        envelope =

                            GeometryLocator.getGeometryManager().createEnvelope(0, 0,

                                image.columns, image.rows, Geometry.SUBTYPES.GEOM2D);

                        }

                        resource.notifyClose();

                        resource.setData(image);

                    } finally  {

                        if( reader != null ) {

                            reader.close();

                        }

                    }

                    return null;

                }

            });

        } catch (Exception e) {

            this.image = null;

            try {

                throw new OpenException(resource.getName(), e);

            } catch (AccessResourceException e1) {

                throw new OpenException(getProviderName(), e);

            }

        } finally {

            this.taskStatus.remove();

        }

    }

    private Envelope createWLDEnvelope(List<String> wldParams){

        double pixelSizeX=Double.valueOf(wldParams.get(0));

        double rotationAxisY = Double.valueOf(wldParams.get(1));

        double rotationAxisX = Double.valueOf(wldParams.get(2));

        double pixelSizeY = Double.valueOf(wldParams.get(3));

        double upperLeftPixelCenterCoordX = Double.valueOf(wldParams.get(4));

        double upperLeftPixelCenterCoordY = Double.valueOf(wldParams.get(5));

        if (0.0 != rotationAxisX || 0.0 != rotationAxisY) {

            logger.warn(

                "Rotation in wld file not implemented yet. It will be ignored");

        }

        double leftMostX = upperLeftPixelCenterCoordX - (pixelSizeX * 0.5);

        double upperMostY = upperLeftPixelCenterCoordY - (pixelSizeY * 0.5);

        double height=image.rows*pixelSizeY;

        double width=image.columns*pixelSizeX;

        // double minX, double minY, double maxX, double maxY, int subType

        try {

            envelope = GeometryLocator.getGeometryManager().createEnvelope(

                Math.min(leftMostX,leftMostX + width),

                Math.min(upperMostY,upperMostY + height),

                Math.max(leftMostX,leftMostX + width),

                Math.max(upperMostY,upperMostY + height),

                Geometry.SUBTYPES.GEOM2D);

        } catch (LocatorException | CreateEnvelopeException e) {

            logger.warn(

                "Failed to create envelope from wld file with coords: minx:"+leftMostX+

                ", miny:"+upperMostY+", maxX: "+leftMostX + width+", maxY: "+upperMostY + height);

            e.printStackTrace();

        }

        return envelope;

    }

    @Override

    public Object getDynValue(String name) throws DynFieldNotFoundException {

        if( DataStore.METADATA_ENVELOPE.equalsIgnoreCase(name) ) {

            return this.envelope;

        } else if( DataStore.METADATA_CRS.equalsIgnoreCase(name) ) {

            IProjection pro = this.getJimiParameters().getCRS();

            if (pro != null) {

                return pro;

            }

        }

        return super.getDynValue(name);

    }

    @Override

    public void close() throws CloseException {

        this.image = null;

    }

    @Override

    public ResourceProvider getResource() {

        return this.resource;

    }

    @Override

    public Object getSourceId() {

        return this.getJimiParameters().getFile();

    }

    @Override

    public String getProviderName() {

        return NAME;

    }

    @Override

    public String getName() {

        String name = this.getJimiParameters().getFile().getName();

        return FilenameUtils.getBaseName(name);

    }

    @Override

    public String getFullName() {

        return this.getJimiParameters().getFile().getAbsolutePath();

    }

    @Override

    public boolean closeResourceRequested(ResourceProvider resource) {

        return true;

    }

    @Override

    /*

     * (non-Javadoc)

     *

     * @see

     * org.gvsig.fmap.dal.resource.spi.ResourceConsumer#resourceChanged(org.

     * gvsig.fmap.dal.resource.spi.ResourceProvider)

     */

    public void resourceChanged(ResourceProvider resource) {

        this.getStoreServices().notifyChange(

            DataStoreNotification.RESOURCE_CHANGED,

            resource);

    }

    @Override

    /* (non-Javadoc)

     * @see org.gvsig.fmap.dal.feature.spi.memory.AbstractMemoryStoreProvider#doDispose()

     */

    protected void doDispose() throws BaseException {

        super.doDispose();

        resource.removeConsumer(this);

    }

    private void waitImage(Image image)

    {

        if (waitComponent == null)

        {

            waitComponent = new Canvas();

        }

        MediaTracker tracker = new MediaTracker(waitComponent);

        tracker.addImage(image, 0);

        try

        {

            tracker.waitForAll();

        }

        catch (InterruptedException e)

        {

            // do nothing

        }

    }

    public class NewImageConsumer implements ImageConsumer, Runnable

    {

       private ImageProducer _ip;

       private Thread _thr;

       private boolean _f;

       private int _n;

       public void addImage(JimiRasterImage i)

       {

          _ip = i.getImageProducer();

          _ip.addConsumer(this);

          _thr = Thread.currentThread();

          _f = false;

          _n = -1;

       }

       public int waitFor()

       {

          new Thread(this).start();

          while (_f == false) _thr.suspend();

          return _n;

       }

       public void imageComplete(int nStatus)

       {

          _f = true;

          _n = nStatus;

          _ip.removeConsumer(this);

          _thr.resume();

       }

       public void run()

       {

          _ip.startProduction(this);

       }

       public void setColorModel(ColorModel cm)

       {

          ;

       }

       public void setDimensions(int w, int h)

       {

          ;

       }

       public void setHints(int nHints)

       {

          ;

       }

       public void setProperties(Hashtable htProperties)

       {

          ;

       }

       public void setPixels(int x, int y, int w, int h,

                             ColorModel cm, byte rgb[],

                             int nOffset, int nScansize)

       {

          ;

       }

       public void setPixels(int x, int y, int w, int h,

                             ColorModel cm, int rgn[],

                             int nOffset, int nScansize)

       {

          ;

       }

    }

    public MemoryImage getMemoryImage(){

        return image;

    }

}