Application: gvSIG desktop » gvSIG raster

import org.gvsig.fmap.dal.coverage.store.parameter.RasterDataParameters;

    public static String NAME = "Gdal Store";

    public static String DESCRIPTION = "Gdal Raster file";

    public static final String METADATA_DEFINITION_NAME = "GdalStore";

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

    public static final String FORMAT_GTiff = "GTiff";

    public static final String FORMAT_VRT = "VRT";

    public static final String FORMAT_NITF = "NITF";

    public static final String FORMAT_HFA = "HFA";

    public static final String FORMAT_ELAS = "ELAS";

    public static final String FORMAT_MEM = "MEM";

    public static final String FORMAT_BMP = "BMP";

    public static final String FORMAT_PCIDSK = "PCIDSK";

    public static final String FORMAT_ILWIS = "ILWIS";

    public static final String FORMAT_HDF4 = "HDF4Image";

    public static final String FORMAT_PNM = "PNM";

    public static final String FORMAT_ENVI = "ENVI";

    public static final String FORMAT_EHDR = "EHdr";

    public static final String FORMAT_PAUX = "PAux";

    public static final String FORMAT_MFF = "MFF";

    public static final String FORMAT_MFF2 = "MFF2";

    public static final String FORMAT_BT = "BT";

    public static final String FORMAT_IDA = "IDA";

    public static final String FORMAT_RMF = "RMF";

    public static final String FORMAT_RST = "RST";

    public static final String FORMAT_LEVELLER = "Leveller";

    public static final String FORMAT_TERRAGEN = "Terragen";

    public static final String FORMAT_ERS = "ERS";

    public static final String FORMAT_INGR = "INGR";

    public static final String FORMAT_GSAG = "GSAG";

    public static final String FORMAT_GSBG = "GSBG";

    public static final String FORMAT_ADRG = "ADRG";

    public static final String FORMAT_JP2 = "JPEG2000";

    public static final String FORMAT_GRD = "GRD";

    public static final int BAND_HEIGHT = 64;

    protected GdalDataSource file = null;

    private Extent viewRequest = null;

    protected static String[][] formatList = null;

    public static void register() {

        ExtensionPointManager extensionPoints = ToolsLocator.getExtensionPointManager();

        registerFormats();

        ExtensionPoint point = extensionPoints.get("DefaultRasterProvider");

        point.append("reader", GdalProvider.NAME, GdalProvider.class);

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

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

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

            dataman.registerStoreProvider(NAME,

                    GdalProvider.class, GdalDataParameters.class);

        }

        if (DALFileLocator.getFilesystemServerExplorerManager() != null) {

            DALFileLocator.getFilesystemServerExplorerManager().registerProvider(

                    NAME, DESCRIPTION,

                    GdalFilesystemServerExplorer.class);

        }

        dataman.registerStoreFactory(NAME, DefaultStoreFactory.class);

    }

    private static void registerFormats() {

        formatList = new String[][]{

            new String[]{"bmp", "image/bmp"},

            new String[]{"gif", "image/gif"},

            new String[]{"tif", "image/tiff"},

            new String[]{"tiff", "image/tiff"},

            new String[]{"jpg", "image/jpeg"},

            new String[]{"jpeg", "image/jpeg"},

            new String[]{"png", "image/png"},

            new String[]{"vrt", "image/vrt"},

            new String[]{"dat", "image/dat"}, // Envi

            new String[]{"lan", "image/lan"}, // Erdas

            new String[]{"gis", "image/gis"}, // Erdas

            new String[]{"img", "image/img"}, // Erdas

            new String[]{"pix", "image/pix"},// PCI Geomatics

            new String[]{"aux", "image/aux"}, // PCI Geomatics

            new String[]{"adf", "image/adf"}, // ESRI Grids

            new String[]{"mpr", "image/mpr"}, // Ilwis

            new String[]{"mpl", "image/mpl"}, // Ilwis

            new String[]{"map", "image/map"},// PC Raster

            new String[]{"asc", "image/asc"},

            new String[]{"pgm", "image/pgn"},//Ficheros PNM en escala de grises

            new String[]{"ppm", "image/ppm"},//Ficheros PNM en RGB

            new String[]{"rst", "image/rst"},//IDRISIS

            new String[]{"rmf", "image/rmf"},//Raster Matrix Format

            new String[]{"nos", "image/nos"},

            new String[]{"kap", "image/kap"},

            new String[]{"hdr", "image/hdr"},

            new String[]{"raw", "image/raw"},

            new String[]{"ers", "image/ers"},

            new String[]{"xml", "image/xml"},

            new String[]{"grd", "image/grd"},

            /*

             new String[] {"jp2","image/jp2" },

             new String[] {"mrsid","image/mrsid" },

             new String[] {"ecw","image/ecw" },

             */

            new String[]{"txt", "image/txt"}

        };

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

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

        }

    }

    public String[] getFormatList() {

        String[] fl = new String[formatList.length];

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

            fl[i] = formatList[i][0];

        }

        return fl;

    }

    /**

     * 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][0].compareTo(ext) == 0) {

                return true;

        }

        return false;

    }

    /**

     * Mandatory constructor to instantiate an empty provider

     */

    public GdalProvider() {

    }

    /**

     * Constructor. Abre el dataset.

     *

     * @throws NotSupportedExtensionException

     * @throws OpenException

     * @deprecated use {@link #GdalProvider(URI)}, this constructor will be

     * removed in gvSIG 2.5

     */

    public GdalProvider(String params) throws NotSupportedExtensionException, OpenException {

        super(params);

        if (params instanceof String) {

            GdalDataParameters p = new GdalDataParameters();

            URI uriParam;

                uriParam = new URI((String) params);

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

            p.setURI(uriParam);

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

                    .createDynObject(

                            MetadataLocator.getMetadataManager().getDefinition(

                                    DataStore.METADATA_DEFINITION_NAME)));

            init(p, null);

        }

    }

    /**

     *

                p,

                null,

                ToolsLocator.getDynObjectManager().createDynObject(

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

    public GdalProvider(GdalDataParameters params,

            DataStoreProviderServices storeServices) throws NotSupportedExtensionException {

        super(params, storeServices, ToolsLocator.getDynObjectManager()

                .createDynObject(

                        MetadataLocator.getMetadataManager().getDefinition(

                                DataStore.METADATA_DEFINITION_NAME)));

        init(params, storeServices);

    }

    public GdalProvider(AbstractRasterDataParameters params,

            DataStoreProviderServices storeServices, DynObject metadata) {

        super(params, storeServices, metadata);

    }

    /**

     * Creates file references and loads structures with the information and

     * metadata

     *

     * @param params load parameters

     * @throws NotSupportedExtensionException

     */

    public void init(AbstractRasterDataParameters params,

            DataStoreProviderServices storeServices) throws NotSupportedExtensionException {

        try {

            setParam(storeServices, params);

            String fname = getFileName(params);

            setFName(fname);

            file = new GdalDataSource(fname);

            setColorInterpretation(file.colorInterpr);

            setColorTable(file.palette);

            noData = file.getNoDataValue();

            IProjection proj = null;

            File prjFile = getPrjFile(params.getURI());

            if (prjFile.exists()) {

                String wktEsri = loadPrj(prjFile);

                if (wktEsri != null) {

                    proj = CRSFactory.getCRSFactory().get(ICRSFactory.FORMAT_WKT_ESRI, wktEsri);

                }

            if (proj == null) {

            ownTransformation = file.getOwnTransformation();

            externalTransformation = (AffineTransform) ownTransformation.clone();

            load();

            if (file != null) {

                bandCount = file.getRasterCount();

            }

        } catch (GdalException e) {

            throw new NotSupportedExtensionException("Extension not supported", e);

        } catch (Exception e) {

            System.out.println("Error en GdalOpen");

            e.printStackTrace();

            file = null;

        }

        //Obtenemos el tipo de dato de gdal y lo convertimos el de RasterBuf

        int[] dt = new int[file.getDataType().length];

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

            dt[i] = GdalDataSource.getRasterBufTypeFromGdalType(file.getDataType()[i]);

        }

        setDataType(dt);

        super.init();

        try {

            loadFromRmf(getRmfBlocksManager());

        } catch (ParsingException e) {

            //No lee desde rmf

            logger.debug("Problems reading from the RMF file", e);

        }

    }

    private String getFileName(RasterDataParameters params) throws GdalException {

        File f = new File(params.getURI());

        validRmf(f.getAbsolutePath());

        return translateFileName(f.getAbsolutePath());

    }

            logger.warn("Can't get mime type for GDAL archive.", ex);

    /**

     * Comprueba si el fichero abierto es un RasterMetaFile o una imagen raster.

     *

     * @throws GdalException

     */

    private void validRmf(String file) throws GdalException {

        if (file.endsWith(".rmf")) {

            File f = new File(file);

            try {

                FileReader fr = new FileReader(f);

                BufferedReader br = new BufferedReader(fr);

                char[] buffer = new char[5];

                br.read(buffer);

                StringBuffer st = new StringBuffer(new String(buffer));

                br.close();

                fr.close();

                if (st.toString().equals("<?xml")) {

                    throw new GdalException("RasterMetaFile");

                }

            } catch (FileNotFoundException e) {

                throw new GdalException("File Not Found");

            } catch (IOException e) {

                throw new GdalException("");

            }

        }

    }

    public RasterProvider load() {

        return this;

    }

    public boolean isOpen() {

        if (file != null && file.isOpen()) {

            return true;

        }

        return false;

    }

    public URI translateURI(URI uri) {

        return uri;

    }

    /**

     * Asigna el extent de la vista actual. existe un fichero .rmf debemos hacer

     * una transformaci?n de la vista asignada ya que la petici?n viene en

     * coordenadas del fichero .rmf y la vista (v) ha de estar en coordenadas

     * del fichero.

     *

     */

    public void setView(Extent e) {

        viewRequest = new ExtentImpl(e);

    }

    public Extent getView() {

        return viewRequest;

    }

    public double getWidth() {

        return file.width;

    }

    public double getHeight() {

        return file.height;

    }

    /**

     * 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 {

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

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

        }

        try {

            return file.readCompleteLine(line, band);

        } catch (GdalException e) {

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

        }

    }

    public Object readBlock(int pos, int blockHeight, double scale)

            throws InvalidSetViewException, FileNotOpenException, RasterDriverException, ProcessInterruptedException {

        if (pos < 0) {

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

        }

        if ((pos + blockHeight) > getHeight()) {

            blockHeight = Math.abs(((int) getHeight()) - pos);

        }

        try {

            return file.readBlock(pos, blockHeight, scale);

        } catch (GdalException e) {

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

        }

    }

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

        if (file != null) {

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

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

            }

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

            return data[band];

        }

        throw new FileNotOpenException("GdalNative not exist");

    }

    @Override

    public void loadBuffer(SpiRasterQuery q)

            throws ProcessInterruptedException, RasterDriverException {

        setView(q.getAdjustedRequestBoundingBox());

        try {

            file.readWindow(q.getBufferForProviders(),

                    q.getBandList(),

                    q.getAdjustedRequestBoundingBox(),

                    q.getAdjustedRequestPxWindow(),

                    q.getTaskStatus());

        } catch (GdalException e) {

            throw new RasterDriverException("Error reading data", e);

        }

    }

    public int getBlockSize() {

        if (file != null) {

            return file.getBlockSize();

        } else {

            return 0;

        }

    }

    public DataStoreMetadata getMetadata() {

        if (file != null) {

            return file.metadata;

        } else {

            return null;

        }

    }

    public Transparency getTransparency() {

        return file.fileTransparency;

    }

    public boolean isGeoreferenced() {

        if (file != null) {

            return file.georeferenced;

        } else {

            return false;

        }

    }

    /**

     * 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() {

        if (file != null) {

            return file.isSupersampling;

        } else {

            return false;

        }

    }

    protected GdalDataSource getNative() {

        return file;

    }

    public void setAffineTransform(AffineTransform t) {

        super.setAffineTransform(t);

        file.setExternalTransform(t);

    }

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

        if (band >= getBandCount()) {

            throw new BandAccessException("Wrong band");

        }

        try {

            return file.getRasterBand(band + 1).getOverviewCount();

        } catch (GdalException e) {

            throw new RasterDriverException("");

        }

    }

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

        if (band >= getBandCount()) {

            throw new BandAccessException("Wrong band");

        }

        try {

            if (overview >= file.getRasterBand(band + 1).getOverviewCount()) {

                throw new BandAccessException("Wrong overview count");

            }

            return file.getRasterBand(band + 1).getOverview(overview).getRasterBandXSize();

        } catch (GdalException e) {

            throw new RasterDriverException("");

        }

    }

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

        if (band >= getBandCount()) {

            throw new BandAccessException("Wrong band");

        }

        try {

            if (overview >= file.getRasterBand(band + 1).getOverviewCount()) {

                throw new BandAccessException("Wrong overview count");

            }

            return file.getRasterBand(band + 1).getOverview(overview).getRasterBandYSize();

        } catch (GdalException e) {

            throw new RasterDriverException("");

        }

    }

    public boolean isOverviewsSupported() {

        return true;

    }

    public boolean isReproyectable() {

        return true;

    }

    public boolean needEnhanced() {

        return (getDataType()[0] != Buffer.TYPE_BYTE);

        //Eliminada 30/5/2013

        //|| (getBandCount() == 1 && getDataType()[0] == Buffer.TYPE_BYTE));

    }

    public String getProviderName() {

        return NAME;

    }

    public void setStatus(RasterProvider provider) {

        if (provider instanceof GdalProvider) {

            //Not implemented yet

        }

    }

    public TileServer getTileServer() {

        if (tileServer == null) {

            DefaultRasterStore store = new DefaultRasterStore();

            store.setProvider(this);

            tileServer = new FileTileServer(store);

        }

        return tileServer;

    }

    public void close() {

        if (file != null) {

            file.dispose();

        }

        try {

            finalize();

        } catch (Throwable e) {

        }

    }

    protected void finalize() throws Throwable {

        file = null;

        viewRequest = null;

        if (formatList != null) {

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

                formatList[i] = null;

            }

            formatList = null;

        }

        super.finalize();

    }

    private File getPrjFile(URI uri) {

        if ("file".equalsIgnoreCase(uri.getScheme())) {

            String uriPath = new File(uri).getAbsolutePath();

            String prjPath = FilenameUtils.removeExtension(uriPath) + ".prj";

    }

    ;

    private String loadPrj(File prjFile) {

}

	 * @param filename	Nombre del fichero.

            */

        public void open(String filename, int access) throws GdalException, IOException {

            if (filename == null) {

                throw new IllegalArgumentException("filename is null");

            }

            if ((access < 0) || (access > 1)) {

                throw new GdalException("Access type mistmatch (access="+access+").");

            }

            this.dataset = gdal.Open(filename, access);

            if (this.dataset == null) {

                throw new GdalException("Can't open file '" + filename + "'.");

            }

        }