Application: gvSIG desktop » gvSIG raster

<?xml version="1.0" encoding="UTF-8"?>

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">

    <modelVersion>4.0.0</modelVersion>

    <artifactId>org.gvsig.mosaic.provider</artifactId>

    <packaging>jar</packaging>

    <name>${project.artifactId}</name>

    <description></description>

    <parent>

        <groupId>org.gvsig</groupId>

        <artifactId>org.gvsig.mosaic</artifactId>

        <version>3.0.0-SNAPSHOT</version>

    </parent>

    <dependencies>

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.mosaic.lib.impl</artifactId>

            <scope>compile</scope>

        </dependency>

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.fmap.dal.api</artifactId>

            <scope>compile</scope>

        </dependency>

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.fmap.dal.spi</artifactId>

            <scope>compile</scope>

        </dependency>

        <!-- TESTS -->

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.tools.lib</artifactId>

            <type>jar</type>

            <version>3.0.152</version>

        </dependency>

        <dependency>

            <groupId>junit</groupId>

            <artifactId>junit</artifactId>

            <version>3.8.1</version>

            <type>jar</type>

        </dependency>

        <dependency>

            <groupId>org.gvsig</groupId>

            <artifactId>org.gvsig.fmap.dal.impl</artifactId>

            <version>3.0.0-SNAPSHOT</version>

            <type>jar</type>

        </dependency>

    </dependencies>

    <build>

        <plugins>

            <!--            

            <plugin>

                <groupId>org.codehaus.mojo</groupId>

                <artifactId>animal-sniffer-maven-plugin</artifactId>

                <executions>

                    <execution>

                        <id>check-java-api</id>

                        <phase>package</phase>

                        <goals>

                            <goal>check</goal>

                        </goals>

                        <configuration>

                            <skip>true</skip>

                            <signature>

                                <groupId>org.codehaus.mojo.signature</groupId>

                                <artifactId>java18</artifactId>

                                <version>1.0</version>

                            </signature>

                        </configuration>

                    </execution>

                </executions>

            </plugin>

            -->

        </plugins>

    </build>

</project>

org.gvsig.mosaic.MosaicStoreLibrary

<?xml version="1.0"?>

<!--

Definitions of metadata fields of a JIMI file.

 -->

<definitions>

  <version>1.0.0</version>

  <classes>

    <class name="MosaicStore" namespace="Metadata">

      <extends>

      	<class namespace="Metadata" name="SpatialProvider"/>

      </extends>

      <description>Metadata of a Mosaic store</description>

      <fields>

      </fields>

    </class>

  </classes>

</definitions>

<?xml version="1.0"?>

<definitions>

  <version>1.0.0</version>

  <classes>

    <class name="MosaicStoreProviderParameters">

       <extends>

      	<class namespace="dal" name="ProviderParameters"/>

      </extends>

      <description>Store the parameters need to open a mosaic file</description>

      <fields>

        <field name="mosaicFile" type="File">

            <description></description>

        </field>

      </fields>

    </class>

  </classes>

</definitions>

/*

 * To change this license header, choose License Headers in Project Properties.

 * To change this template file, choose Tools | Templates

 * and open the template in the editor.

 */

package org.gvsig.mosaic;

import java.util.ArrayList;

import java.util.List;

import java.util.logging.Level;

import java.util.logging.Logger;

import org.gvsig.fmap.dal.DALFileLibrary;

import org.gvsig.fmap.dal.DALLibrary;

import org.gvsig.fmap.dal.FileHelper;

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

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

import org.gvsig.metadata.exceptions.MetadataException;

import org.gvsig.tools.library.AbstractLibrary;

import org.gvsig.tools.library.LibraryException;

/**

 *

 * @author osc

 */

public class MosaicStoreLibrary extends AbstractLibrary {

    @Override

    public void doRegistration() {

        registerAsServiceOf(DALLibrary.class);

        require(DALFileLibrary.class);

    }

	@Override

	protected void doInitialize() throws LibraryException {

	}

	@Override

	protected void doPostInitialize() throws LibraryException {

            List<Throwable> exs = new ArrayList<Throwable>();

//            String filename = "MosaicStoreParameters.xml";

            FileHelper.registerParametersDefinition(

                    MosaicStoreProviderParameters.PARAMETERS_DEFINITION_NAME,

                    MosaicStoreProviderParameters.class,

                    MosaicStoreProvider.NAME+"Parameters.xml");

        try {

            FileHelper.registerMetadataDefinition(

                    MosaicStoreProvider.METADATA_DEFINITION_NAME,

                    MosaicStoreProvider.class, 

                    MosaicStoreProvider.NAME+"Metadata.xml");

        } catch (MetadataException ex) {

            throw new RuntimeException("Not able to register metadata definition",ex);       

            }

//		List<Throwable> exs = new ArrayList<Throwable>();

//

//		FileHelper.registerParametersDefinition(

//				PngStoreProviderParameters.PARAMETERS_DEFINITION_NAME,

//				PngStoreProviderParameters.class, PngStoreProvider.NAME+"Parameters.xml");

//		try {

//			FileHelper.registerMetadataDefinition(

//					PngStoreProvider.METADATA_DEFINITION_NAME,

//					PngStoreProvider.class, PngStoreProvider.NAME+"Metadata.xml");

//		} catch (MetadataException e) {

//			exs.add(e);

//		}

//

            DataManagerProviderServices dataman = DALSPILocator.getDataManagerProviderServices();

//

            try {

                if (!dataman.getStoreProviders()

                        .contains(MosaicStoreProvider.NAME)) {

                    dataman.registerStoreProviderFactory(

                            new MosaicStoreProviderFactory(

                                    MosaicStoreProvider.NAME,

                                    MosaicStoreProvider.DESCRIPTION));

                }

            } catch (RuntimeException e) {

                exs.add(e);

            }

		//FIXME: Cambiar usando la factoria

//		try {

//			DALFileLocator.getFilesystemServerExplorerManager()

//					.registerProvider(MosaicStoreProvider.NAME,

//					    MosaicStoreProvider.DESCRIPTION,

//							PngFileSystemServerProvider.class);

//		} catch (RuntimeException e) {

//			exs.add(e);

//		}

        if (exs.size() > 0) {

            throw new LibraryException(this.getClass(), exs);

        }

    }

}

/*

 * To change this license header, choose License Headers in Project Properties.

 * To change this template file, choose Tools | Templates

 * and open the template in the editor.

 */

package org.gvsig.mosaic;

//import org.gvsig.mosaic.lib.impl.DefaultMosaicFile;

import java.io.IOException;

import java.nio.Buffer;

import java.util.ArrayList;

import java.util.List;

import java.util.Map;

import java.util.logging.Level;

import java.util.logging.Logger;

import org.cresques.cts.IProjection;

import org.gvsig.fmap.dal.DataQuery;

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

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

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

import org.gvsig.fmap.dal.raster.impl.DefaultRasterStore;

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.GeometryLocator;

import org.gvsig.fmap.geom.GeometryManager;

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

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

import org.gvsig.fmap.geom.operation.GeometryOperationException;

import org.gvsig.fmap.geom.operation.GeometryOperationNotSupportedException;

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

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

import org.gvsig.mosaic.lib.api.MosaicTile;

import org.gvsig.mosaic.lib.api.MosaicTiles;

import org.gvsig.mosaic.lib.impl.DefaultMosaicFile;

//import org.gvsig.mosaic.lib.impl.DefaultMosaicFile.Tile;

//import org.gvsig.mosaic.lib.impl.DefaultTile;

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

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

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

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

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.TileStruct;

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

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

import org.gvsig.tools.locator.LocatorException;

/**

 *

 * @author osc

 */

public class MosaicPageManager implements BandTileManager {

    private final int numBand;

    private final int bandType;

    private final DefaultMosaicFile mosaic;

    private Envelope envelope; // cuano se abre el envelope viene de los params createWLDEnvelope

    private final int rows;

    private final int cols;

//    private final int rowsPerTile;

//    private final int columnsPerTile;

    private final NoData noData;

    private final MosaicTiles mosaicTiles;

    private final Object values;

    private final TileStruct tileStruct;

    private final List<BandInfo> tileBandsInfo;

    /**

     *

     * @param numBand

     * @param bandType

     * @param rows

     * @param cols

     */

    public MosaicPageManager(DefaultMosaicFile mosaic, int numBand, int bandType) {

        this.numBand = numBand;

        this.bandType = bandType;

        this.mosaic = mosaic;

        this.mosaicTiles = this.mosaic.getTiles();

        this.rows = mosaic.getRows();

        this.cols = mosaic.getCols();

        this.noData = BufferLocator.getBufferManager().createNoData(-99999, this.bandType);

        this.values = null;

        this.envelope = null;

        this.tileStruct = mosaic.getTileStruct();

        this.tileBandsInfo = mosaic.getBandsInfo();

        BandInfo bandInfo = BufferLocator.getBufferManager().createBandInfo(numBand, "MosaicBand_"+numBand, "Mosaic Band", bandType, (List<Map.Entry<Object, Object>>) values);

        try {

            this.envelope = GeometryLocator.getGeometryManager().createEnvelope(bandType);

            for (MosaicTile mosaicTile : mosaicTiles) {

                // TODO OSC: wld??

                //List<String> wldParams = (List<String>) rasterStore.getParameters().getDynValue("wldParams");

                DefaultRasterStore rasterStore = mosaicTile.getStore();

                Envelope env = rasterStore.getEnvelope();

                this.envelope.add(env);

            }

        } catch (CreateEnvelopeException | DataException | LocatorException ex) {

            this.envelope = null;

        }

    }

    /**

     *

     * @param row

     * @param col

     * @param dataType

     */

    @Override

    public Band load(int row, int col, int dataType) {

        // Crear envelope del tile correspondiente

        // Envelope del manager lo divide

        double w = this.tileStruct.getEnvelope().getGeometry().getBounds().getWidth();

        double h = this.tileStruct.getEnvelope().getGeometry().getBounds().getHeight();

        Point coordinates = this.tileStruct.getEnvelope().getUpperCorner();

        double xCoord = coordinates.getX();

        double yCoord = coordinates.getY();

        Double pixelSize = this.tileStruct.getPixelSizePerZoomLevel().get(0); //TODO pixel size del primer zoom

        double xTileSize = this.getColumnsPerTile()*pixelSize;

        double yTileSize = this.getRowsPerTile()*pixelSize;

        double newX = xCoord + (xTileSize*col);

        double newY = yCoord + (yTileSize*row);

        Point newUpperPoint = null;

        Point newLowerCorner = null;

        GeometryManager geometryManager = GeometryLocator.getGeometryManager();

        try {

            newUpperPoint  = geometryManager.createPoint(newX, newY, dataType);

            newLowerCorner = geometryManager.createPoint(xTileSize+newX, yTileSize-newY, dataType);

        } catch (CreateGeometryException ex) {

            throw new RuntimeException("Not able to create points for the new query envelope");

        }

        Envelope envelopeQuery = null;

        try {

            envelopeQuery = geometryManager.createEnvelope(dataType);

            envelopeQuery.setUpperCorner(newUpperPoint);

            envelopeQuery.setLowerCorner(newLowerCorner);

        } catch (CreateEnvelopeException ex) {

            throw new RuntimeException("Not able to create new query envelope");

        }

        BufferManager bufferManager = BufferLocator.getBufferManager();

//        int dataTypeSize = bufferManager.getDataTypeSize(dataType);

        // Calculo tiles

        //byte[][] byteArray = new byte[getRowsPerTile()*getColumnsPerTile()][];

        Band band;

        try {

            band = bufferManager.createBand(dataType, this.getRowsPerTile(), this.getColumnsPerTile(), this.noData, this);

        } catch (BandException ex) {

            return null;

        }

        //

        fillBandNone(band); //TODO eliminar

        fillBand(band, envelopeQuery,pixelSize);

        return band;

        }

    /**

     *

     * @param band

     * @param envelopeQuery

     * @return

     */

    public Band fillBand(Band band, Envelope envelopeQuery, double pixelSize) {

        int bRows = band.getRows();

        int bCols = band.getColumns();

//        BufferManager bufferManager = BufferLocator.getBufferManager();

//        BufferDimensions newDimensions = bufferManager.createBufferDimensions(bRows, bCols, envelopeQuery);

        int[] bandDataTypes = null;

        bandDataTypes[0] = band.getDataType();

        IProjection projection = envelopeQuery.getGeometry().getProjection();

//        try {

//            //org.gvsig.raster.lib.buffer.api.Buffer newBuffer = bufferManager.createBuffer(bRows, bCols, bandDataTypes, projection);

//        } catch (BufferException ex) {

//            throw new RuntimeException("Not able to create buffer");

//        }

        for (int i = 0; i < mosaicTiles.size(); i++) {

            MosaicTile tile = mosaicTiles.get(i);

            DefaultRasterStore tileStore = tile.getStore();

            int numTileBand = this.tileBandsInfo.get(i).getBand();

            BandDescriptor tileBand = tileStore.getBandDescriptor(numTileBand); // banda corresponde a cada tile en este pagemanager

            DataQuery dataQuery = null;

            Envelope tileStoreEnvelope = null;

            try {

                tileStoreEnvelope = tileStore.getEnvelope();

            } catch (Exception ex) {

                tileStoreEnvelope = null;

            }

            Geometry interEnvelope = null;

            if (tileStoreEnvelope.intersects(envelopeQuery)) {

                    try {

                        interEnvelope = tileStoreEnvelope.getGeometry().intersection(envelopeQuery.getGeometry());

                    } catch (Exception ex) {

                    }

            } 

            if (interEnvelope==null) {

                continue;   

            } else {

                //fill band with this part of the interEnvelope

                //find col of the tile to fill band

                int x0cols = (int) Math.ceil((interEnvelope.getBounds().getMinX()-envelopeQuery.getUpperCorner().getX())/pixelSize);

//                int x1cols = (int) (Math.ceil(interEnvelope.getBounds().getMinX()-envelopeQuery.getLowerCorner().getX())/pixelSize));

                int x1cols = (int) Math.ceil((interEnvelope.getBounds().getMinX()-envelopeQuery.getLowerCorner().getX())/pixelSize);

//                int y0cols = (int) Math.ceil((envelopeQuery.getUpperCorner()-interEnvelope.getBounds().getMaxY())/pixelSize));

                int x0rows = (int) Math.ceil((envelopeQuery.getUpperCorner().getY() - interEnvelope.getBounds().getMaxY())/pixelSize);

                int x1rows = (int) Math.ceil((envelopeQuery.getUpperCorner().getY() - interEnvelope.getBounds().getMinY())/pixelSize);

                Band getBand;

                try {

                    getBand = tileStore.getRasterSet().getBand(numTileBand);

                } catch (DataException ex) {

                    throw new RuntimeException("Not able to get the band");

                }

                Object[] rowTileArray = new Object[getRowsPerTile()];

                Object[] newRowTileArray = new Object[x1cols-x0cols];

                //falta calcular hasta cual row

                for (int j = x0rows; j < x1rows; j++) {

                    getBand.fetchRow(j, rowTileArray);

                    System.arraycopy(newRowTileArray, 0, rowTileArray, x0cols, x1cols);

                    band.putRow(j, newRowTileArray);

                }

            }

        }

        return band;

    }

    public void fillBandNone(Band band) {

        for (int i = 0; i < band.getRows(); i++) {

            for (int j = 0; j < band.getColumns(); j++) {

                band.set(i, j, this.noData);

            }

        }

    }

    @Override

    public void save(Buffer buffer, int row, int rows, int col, int cols, int dataType) throws IOException {

       // 

    }

    @Override

    public BandInfo getBandInfo() {

        return null;

    }

    @Override

    public int getRowsPerTile() {

        return this.mosaic.getTileStruct().getRowsPerTile(); 

    }

    @Override

    public int getColumnsPerTile() {

       return this.mosaic.getTileStruct().getColumnsPerTile();

    }

    @Override

    public TileStruct getTileStruct() {

        return this.tileStruct;

    }

    @Override

    public boolean isSupportedSave() {

        return false;

    }

    @Override

    public void dispose() {

        //throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.

    }

}

/*

 * To change this license header, choose License Headers in Project Properties.

 * To change this template file, choose Tools | Templates

 * and open the template in the editor.

 */

package org.gvsig.mosaic;

import java.io.IOException;

import java.nio.Buffer;

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

import org.gvsig.mosaic.lib.api.MosaicFile;

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

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

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

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

/**

 *

 * @author osc

 */

public class MosaicPageManager implements BandTileManager {

    private final MosaicFile mosaic;

//    private final int rows;

//    private final int cols;

    private final int rowsPerTile;

    private final int columnsPerTile;

    private final int numBand;

    /**

     *

     * @param numBand

     * @param bandType

     * @param rows

     * @param cols

     */

    public MosaicPageManager(MosaicFile mosaic, int numBand, int bandType, int rowsPerTile, int columnsPerTile) {

        this.mosaic = mosaic;

        this.numBand = numBand;

        this.rowsPerTile = rowsPerTile;

        this.columnsPerTile = columnsPerTile;

    }

    /**

     *

     * @param row

     * @param col

     * @param dataType

     */

    @Override

    public Band load(int row, int col, int dataType) {

        Envelope envelope = this.mosaic.getEnvelope(

                col*columnsPerTile,

                row*rowsPerTile,

                columnsPerTile,

                rowsPerTile

        );

        Band band = this.mosaic.getBufferBand(envelope,this.numBand);

        return band;

        }

    @Override

    public void save(Buffer buffer, int row, int rows, int col, int cols, int dataType) throws IOException {

       // 

    }

    @Override

    public BandInfo getBandInfo() {

        return null;

    }

    @Override

    public int getRowsPerTile() {

        return this.rowsPerTile;

    }

    @Override

    public int getColumnsPerTile() {

       return this.columnsPerTile;

    }

    @Override

    public TileStruct getTileStruct() {

        return null;

    }

    @Override

    public boolean isSupportedSave() {

        return false;

    }

    @Override

    public void dispose() {

        //throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.

    }

    private Envelope calculateEnvelopeForTile(int row, int col) {

        return null;

    }

}

/*

 * To change this license header, choose License Headers in Project Properties.

 * To change this template file, choose Tools | Templates

 * and open the template in the editor.

 */

package org.gvsig.mosaic;

//import org.gvsig.mosaic.lib.impl.DefaultMosaicFile;

import java.awt.Image;

import java.util.ArrayList;

import java.util.Collection;

import java.util.Iterator;

import java.util.List;

import org.apache.commons.io.FilenameUtils;

import org.cresques.cts.IProjection;

import org.gvsig.fmap.dal.DataServerExplorer;

import org.gvsig.fmap.dal.DataStore;

import org.gvsig.fmap.dal.DataStoreParameters;

import org.gvsig.fmap.dal.FileHelper;

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

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.BandDescriptor;

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

import org.gvsig.fmap.dal.raster.RasterStore;

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

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

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

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.spi.DataStoreProviderServices;

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

import org.gvsig.mosaic.lib.api.MosaicFile;

import org.gvsig.mosaic.lib.api.MosaicLocator;

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

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

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

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

import org.gvsig.timesupport.Interval;

import org.gvsig.tools.dynobject.DynClass;

import org.gvsig.tools.dynobject.DynObject;

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

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

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

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;

/**

 *

 * @author osc

 */

public final class MosaicStoreProvider extends AbstractRasterStoreProvider   {

    public static String NAME = "MosaicStore";

    public static String DESCRIPTION = "Mosaic store provider";

    public static final String METADATA_DEFINITION_NAME = NAME;

    public static final String MOSAIC_COLS = "cols";

    public static final String MOSAIC_ROWS = "rows";

    public static final String MOSAIC_TILES = "tiles";

    public static final String MOSAIC_BANDTILES = "bandTiles";

    public static final String MOSAIC_ENVELOPE = "envelope";

    public static final String MOSAIC_TILESPARAMETERS = "tilesParameters";

    public static final String MOSAIC_BANDTYPES = "bandTypes";

    private List<MosaicFile> tilesParameters;

    private List<RasterStore> tilesStore; // almacena los tilesStore

    private Envelope envelope; // cuano se abre el envelope viene de los params createWLDEnvelope

    private TileStruct tileStruct;

    private List<PageManager> pageManagers; //una por cada banda. los crea el init

    private int rows;

    private int cols;

    //private List<MosaicInfo> mosaicInfo; //info de los datos de cada pagemanagers

    private  MosaicStoreProviderParameters params;

    private DataStoreProviderServices providerServices;

//    private final List bandTiles;

//    private final List<Integer> bandTypes;

    private int numBands;

    private BufferDimensions dimensions;

    private MosaicFile mosaicFile;

    public MosaicStoreProvider(MosaicStoreProviderParameters params, DataStoreProviderServices providerServices) throws InitializeException { //int rows, int cols, List<RasterStore> tilesStore ) {

        super(params, providerServices, FileHelper.newMetadataContainer(METADATA_DEFINITION_NAME));

        this.params = params;

        this.providerServices = providerServices;

        this.dimensions = null;

    }

    //MosaicStoreProvider(MosaicStoreProviderParameters mosaicStoreProviderParameters, DataStoreProviderServices providerServices) {

    //    throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.

    //}

    public List<MosaicFile> getTilesParameters() {

        return tilesParameters;

    }

    public void setTilesParameters(List<MosaicFile> tilesParameters) {

        this.tilesParameters = tilesParameters;

    }

    public List<RasterStore> getTilesStore() {

        return tilesStore;

    }

    public void setTilesStore(List<RasterStore> tilesStore) {

        this.tilesStore = tilesStore;

    }

    public Envelope getEnvelope() {

//        this.getParameters().get

        return this.envelope;

    }

    public void setEnvelope(Envelope envelope) {

        this.envelope = envelope;

    }

    public List<PageManager> getPageManagers() {

        return this.pageManagers;

    }

    public void setPageManagers(List<PageManager> pageManagers) {

        this.pageManagers = pageManagers;

    }

    public int getRows() {

        return this.rows;

    }

    public void setRows(int rows) {

        this.rows = rows;

    }

    public int getCols() {

        return cols;

    }

    public void setCols(int cols) {

        this.cols = cols;

    }

    @Override

    public TileStruct getTileStruct() {

        if (true) {

            return null;

        }

//        List<Double> pixelSizes = new ArrayList<>();

//        Map<Integer, Double> zoomLevels = new HashMap<Integer, Double>();

//

//        if (this.tileStruct == null) {

//

//            tileStruct = new DefaultTileStruct();

//

//            int completeRows =(int) this.getEnvelope().getGeometry().getBounds().getHeight(); //getRaster().getHeight();

//            int completeColumns = (int) this.getEnvelope().getGeometry().getBounds().getWidth();//getRaster().getWidth();

//            double completePixelSizeX = this.getEnvelope().getLength(Geometry.DIMENSIONS.X) / completeColumns;

//            double completePixelSizeY = this.getEnvelope().getLength(Geometry.DIMENSIONS.Y) / completeRows;

//

//            int maximumLength = completeColumns;

//            int tileMaximumLength = tileStruct.getColumnsPerTile(); // tileSizeX;

//            double maximumPixelSize = completePixelSizeX;

//

//            if (completeRows * tileStruct.getRowsPerTile() > completeColumns * tileStruct.getColumnsPerTile()) {

//                maximumLength = completeRows;

//                tileMaximumLength = tileStruct.getRowsPerTile();

//                maximumPixelSize = completePixelSizeY;

//            }

//

//            double pixelSize = maximumPixelSize;

//            while (maximumLength * maximumPixelSize / pixelSize > tileMaximumLength) {

//                pixelSizes.add(pixelSize);

//                pixelSize = pixelSize * 2;

//            }

//            pixelSizes.add(pixelSize);

//            int i = 0;

//            for (int zoomLevel = pixelSizes.size() - 1; zoomLevel >= 0; zoomLevel--) {

//                zoomLevels.put(i, pixelSizes.get(zoomLevel));

//                i++;

//            }

//        }

//

//        return tileStruct;

        return null;

    }

    @Override

    public Image getImageLegend() {

        throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.

    }

    @Override

    public MosaicStoreProviderParameters getParameters() {

        return this.params;

    }

    @Override

    public BufferDimensions getDimensions() {

       if(this.dimensions==null){

            //this.dimensions = BufferLocator.getBufferManager().createBufferDimensions(this.getRaster().getHeight(), this.getRaster().getWidth(), this.envelope);

            //this.dimensions = BufferLocator.getBufferManager().createBufferDimensions(this.getRaster().getHeight(), this.getRaster().getWidth(), this.envelope);

            return this.mosaicFile.getDimensions();

        }

        return this.dimensions;

    }

    @Override

    public boolean isTiled() {

        return true;

    }

    @Override

    public Iterator getChilds() {

        throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.

    }

    @Override

    public DataServerExplorer getExplorer() throws ReadException, ValidateDataParametersException {

        throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.

    }

//    

//    @Override

//    public void open() throws OpenException {

//        

//    }

//

//    @Override

//    public void close() throws CloseException {

//        throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.

//    }

//

//    @Override

//    public ResourceProvider getResource() {

//        throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.

//    }

//

//    @Override

//    public void refresh() throws OpenException, InitializeException {

//        throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.

//    }

//

//    @Override

//    public Object getSourceId() {

//        throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.

//    }

//

    @Override

    public String getProviderName() {

        return NAME;

    }

    @Override

    public String getName() {

        return FilenameUtils.getBaseName(this.getParameters().getFile().getName());

    }

    @Override

    public String getFullName() {

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

    }

//

//    @Override

//    public Interval getInterval() {

//        throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.

//    }

//

//    @Override

//    public Collection getTimes() {

//        throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.

//    }

//

//    @Override

//    public Collection getTimes(Interval interval) {

//        throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.

//    }

//

//    @Override

//    public boolean hasDynMethod(String name) {

//        return this.params.hasDynValue(name);

//    }

//

//    @Override

//    public DynClass getDynClass() {

//        return this.params.getDynClass();

//    }

//

//    @Override

//    public void implement(DynClass dynClass) {

//        this.params.implement(dynClass);

//    }

//

//    @Override

//    public void delegate(DynObject dynObject) {

//    }

//

//    @Override

//    public Object getDynValue(String name) throws DynFieldNotFoundException {

//        return this.params.getDynValue(name);

//    }

//

//    @Override

//    public void setDynValue(String name, Object value) throws DynFieldNotFoundException {

//        this.params.setDynValue(name, value);

//    }

//

//    @Override

//    public boolean hasDynValue(String name) {

//        return this.params.hasDynValue(name);

//    }

//

//    @Override

//    public Object invokeDynMethod(String name, Object[] args) throws DynMethodException {

//        return this.params.invokeDynMethod(name, args);

//    }

//

//    @Override

//    public Object invokeDynMethod(int code, Object[] args) throws DynMethodException {

//        return this.params.invokeDynMethod(code, args);

//    }

//

//    @Override

//    public void clear() {

//        this.params.clear();

//    }

//

//    @Override

//    public void dispose() {

//        

//    }

    @Override

    public Buffer createBuffer(org.gvsig.fmap.dal.raster.RasterQuery rasterQuery) throws BufferException {

        //TODO

        Envelope clip = rasterQuery.getClip();

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

        double pixelSize = rasterQuery.getPixelSize();

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

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

        for (int i = 0; i < bands.size(); i++) {

            BandQuery bandQuery = bands.get(i);

            listBandDataTypes[i] = bandQuery.getDescriptor().getDataType();

            listNoDataTypes[i] = bandQuery.getDescriptor().getNoData();

        }

        BufferManager bufferManager = BufferLocator.getBufferManager();

        IProjection projection;

//        projection = clip.getGeometry().getProjection();

        projection = this.mosaicFile.getCRS();

        int nRows = (int) (clip.getGeometry().getBounds().getHeight() / pixelSize);

        int nCols = (int) (clip.getGeometry().getBounds().getWidth() / pixelSize);

        Buffer buffer = bufferManager.createBuffer(nRows, nCols, listBandDataTypes, listNoDataTypes, projection, clip, this.getPageManagers());

        return buffer;

    }

//

//    protected 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) {

//            

//            //    "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=getRaster().getHeight()*pixelSizeY;

//        double width=getRaster().getWidth()*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) {

//            throw new RuntimeException(

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

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

//            

//        }

//

//        return envelope;

//    }

//    @Override

//    public org.gvsig.fmap.dal.raster.BandDescriptor getBandDescriptor(int band) {

//        throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.

//    }

    @Override

    public int getBands() {

        this.autoOpen();

        return this.numBands;

    }

    @Override

    public void open() throws OpenException {

        if (this.mosaicFile!=null) {

            return;

        }

        this.mosaicFile = MosaicLocator.getMosaicManager().createMosaicFile();

        this.mosaicFile.read(params.getFile());

        this.pageManagers = new ArrayList();

//        try {

//            this.envelope = GeometryLocator.getGeometryManager().createEnvelope(bandTypes.get(0));

//        } catch (CreateEnvelopeException ex) {

//            throw new RuntimeException("Not able to create Envelope");

//        }

        // tileStruct ???

        //this.tileStruct = null; // TODO OSC: Example in AbstractAwtRasterStoreProvider

        // Add to tilesParameters

        // Add MosaicPageManager for each band

//        if (this.bandTiles.size()!=this.bandTypes.size()) {

//            throw new RuntimeException("Not valid sizes. bandTiles!=bandTypes");

//        }

//        // TODO: meterlo en isvalid

//        if (this.mosaicFile.getTiles().size()!=this.mosaicFile.getBandsInfo().size()){

//            throw new RuntimeException("Not valid sizes.");

//        }

        int n = 0;

        this.numBands = this.mosaicFile.getBandsInfo().size();

        for (BandInfo bandInfo : this.mosaicFile.getBandsInfo()) {

            // each size bandInfo == 1 mosaic band

            int iBandNumber = bandInfo.getBand();

            int bandType = bandInfo.getDataType();

            MosaicPageManager mosaicPageManager = new MosaicPageManager(mosaicFile, iBandNumber, bandType, 256, 256);

            this.pageManagers.add(mosaicPageManager);

            BandDescriptorServices bandDescriptor = this.getBandDescriptor(n);

            bandDescriptor.setName(bandInfo.getName());

            bandDescriptor.setDescription(bandInfo.getDescription());

            bandDescriptor.setDataType(bandInfo.getDataType());

        }

        this.envelope = this.getDimensions().getEnvelope();

//        try {

//            this.envelope = GeometryLocator.getGeometryManager().createEnvelope(Geometry.SUBTYPES.GEOM2D);

//        } catch (CreateEnvelopeException ex) {

//            throw new RuntimeException("Not able to create provider envelope");

//        }

//        for (MosaicTile tile : this.mosaicFile.getTiles()) {

//            try {

//                this.envelope.add(tile.getStore().getEnvelope());

//            } catch (DataException | LocatorException | CreateEnvelopeException ex) {

//                throw new RuntimeException("Not able to get envelope from stores");

//            }         

//        }

//            if (this.tilesStore.size()!=bandTile.size()) {

//                throw new RuntimeException("Not valid sizes. tiles!=bandTiles");

//            }

//

//            //Param MosaicFile

//            MosaicFile mosaicFile = mosaicManager.createMosaicFile();

//            MosaicTiles tiles = new DefaultMosaicTiles(mosaicFile); //todo creator

//            ArrayList bandTileInfo = new ArrayList();

//            for (int j = 0; j < bandTile.size(); j++) {

//                int bandTileNumber = (int)bandTile.get(j);

//                if (bandTileNumber==-1) {

//                    continue;

//                }

//                RasterStore rasterStore = this.tilesStore.get(j);

//                bandTileInfo.add(j);

//                tiles.add((OpenRasterStoreParameters) rasterStore.getParameters());

//                //Param envelope

//                Envelope env;

//                try {

//                    env = rasterStore.getEnvelope();

//                } catch (Exception ex) {

//                    env = null;

//                }

//                this.envelope.add(env);

//            }

//            mosaicFile.setTiles(tiles); 

//            mosaicFile.setBandsInfo(bandTileInfo); // banda correspondiente al tile

//            //Params bandType

////            Integer bandType = this.bandTypes.get(iBandNumber);

//            Integer bandType = this.mosaicFile.getTiles().get(iBandNumber).getStore().getBandDescriptor(iBandNumber).getDataType();

//            // i => number corresponding to the new

//            mosaicFile.setRows(this.rows);

//            mosaicFile.setCols(this.cols);

//            mosaicFile.setTileStruct(this.getTileStruct());

//            MosaicPageManager mosaicPageManager = new MosaicPageManager(mosaicFile, iBandNumber, bandType, 256, 256);

//

//

//            this.pageManagers.add(mosaicPageManager);

//            

//        }

//        this.numBands = this.mosaicFile.getTiles().size();

    }

    @Override

    public ResourceProvider getResource() {

        return null;

    }

    @Override

    public Object getSourceId() {

        return this.getParameters().getFile();

    }

    @Override

    public Object getDynValue(String name) throws DynFieldNotFoundException {

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

            this.autoOpen();

            return this.mosaicFile.getCRS();

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

            this.autoOpen();

            return this.mosaicFile.getDimensions().getEnvelope();

        }

        return super.getDynValue(name);

    }

}

/*

 * To change this license header, choose License Headers in Project Properties.

 * To change this template file, choose Tools | Templates

 * and open the template in the editor.

 */

package org.gvsig.mosaic;

import java.io.File;

import org.gvsig.fmap.dal.FileHelper;

import org.gvsig.fmap.dal.OpenDataStoreParameters;

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

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

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

import org.gvsig.tools.dynobject.DelegatedDynObject;

/**

 *

 * @author osc

 */

public class MosaicStoreProviderParameters 

        extends AbstractOpenRasterStoreParameters

        implements OpenDataStoreParameters, FilesystemStoreParameters

    {

    public static final String PARAMETERS_DEFINITION_NAME = "MosaicStoreProviderParameters";

    public static final String PARAM_NAME_FILE = "mosaicFile";

    private final DelegatedDynObject parameters;

    public MosaicStoreProviderParameters() {

        this(PARAMETERS_DEFINITION_NAME);

    }

    protected MosaicStoreProviderParameters(String parametersDefinitionName) {

        this(parametersDefinitionName, MosaicStoreProvider.NAME);

    }

    public MosaicStoreProviderParameters(String parametersDefinitionName, String name) {

        super();

        this.parameters = (DelegatedDynObject) FileHelper.newParameters(parametersDefinitionName);

        this.parameters.setDynValue(DataStoreProviderServices.PROVIDER_PARAMTER_NAME, parametersDefinitionName); //TODO no necesario?

    }

    @Override

    protected DelegatedDynObject getDelegatedDynObject() {

        return this.parameters;

    }

    @Override

    public boolean isValid() {

        //comprobacion de parametros

        return true;

    }

    @Override

    public File getFile() {

        return (File) this.parameters.getDynValue(PARAM_NAME_FILE);

    }

    @Override

    public void setFile(File file) {

        this.parameters.setDynValue(PARAM_NAME_FILE, file);

    }

}

/* 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.mosaic;

import java.io.IOException;

import java.io.InputStream;

import java.net.MalformedURLException;

import java.util.Map;

import java.util.logging.Level;

import java.net.URL;

import java.util.logging.Logger;

import org.gvsig.fmap.dal.DataParameters;

import org.gvsig.fmap.dal.FileHelper;

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

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

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

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dynobject.DynObjectManager;

import org.gvsig.tools.dynobject.DynStruct;

import org.xmlpull.v1.XmlPullParserException;

/**

 *

 * @author osc

 */

public class MosaicStoreProviderFactory extends AbstractRasterStoreProviderFactory {

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

//    private final String idp = "MosaicStoreProviderParameters";

//    private final String process = "MosaicStoreProviderParameters";

//    private final String description = "Dyn for MosaicProvider";

//    private final DynStruct definition;

    public MosaicStoreProviderFactory(String name, String description) {

        super(name, description);

//        

//        DynObjectManager dynObjectManager = ToolsLocator.getDynObjectManager();

//        InputStream resource = this.getClass().getClassLoader().getResourceAsStream("org/gvsig/mosaic/dal/MosaicStoreParameters.xml");

//            Map definitions = null;

//        try {

//            definitions = dynObjectManager.importDynClassDefinitions(resource, this.getClass().getClassLoader());

//        } catch (XmlPullParserException ex) {

//            java.util.logging.Logger.getLogger(MosaicStoreProviderFactory.class.getName()).log(Level.SEVERE, null, ex);

//        } catch (IOException ex) {

//            java.util.logging.Logger.getLogger(MosaicStoreProviderFactory.class.getName()).log(Level.SEVERE, null, ex);

//        }

//        this.definition = (DynStruct) definitions.get("MosaicStoreProviderParameters");

////

////        //dynObjectManager.createDynClass(idp, process, description);

////        URL fileURL = null;

////        try {

////            fileURL = new URL("org/gvsig/mosaic/dal/MosaicStoreParameters.xml");

////        } catch (MalformedURLException ex) {

////            Logger.getLogger(MosaicStoreProviderFactory.class.getName()).log(Level.SEVERE, null, ex);

////        }

////        FileHelper.registerParametersDefinition(

////                MosaicStoreProviderParameters.PARAMETERS_DEFINITION_NAME,

////                MosaicStoreProviderParameters.class,

////                this.getClass().getClassLoader(),

////                fileURL);

//    }

//

//    public DynStruct getDynDefinition() {

//        return this.definition;

//    }

    }

    @Override

    public MosaicStoreProvider createProvider(DataParameters parameters,

        DataStoreProviderServices providerServices) throws InitializeException {

        return new MosaicStoreProvider((MosaicStoreProviderParameters)parameters,providerServices);

    }

    /**

     *

     * @return

     */

    @Override

    public MosaicStoreProviderParameters createParameters() {

        return new MosaicStoreProviderParameters();//this.getDynDefinition().getName());

    }

}