Application: gvSIG desktop

/*

 * 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.basicformats;

import org.gvsig.raster.lib.legend.api.colortable.ColorTable;

public interface CLRFile extends FormatFile {

    public String FILE_EXTENSION = "clr";

    ColorTable getColorTable();

    void setColorTable(ColorTable colorTable);

}

package org.gvsig.basicformats.impl;

import java.io.File;

import java.io.IOException;

import org.apache.commons.io.FileUtils;

import org.apache.commons.io.FilenameUtils;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.basicformats.CPGFile;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

public class DefaultCPGFile extends AbstractFormatFile implements CPGFile {

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

    private File source;

    private String charsetName = null;

    /**

     * Define the valid code pages (equivalent to MSDOS code pages). 

     * This codes are used on the byte 29 of the DBF header to define the DBF

     * codepage.

     *

     * The equivalences of these charsets using Java NIO charset names are

     * defined on the {@link #charsetNames} array (so 0x01 is

     * equivalent to IBM437, 0x02 to IBM850, etc)

     *

     * See some other equivalences in:

     * https://github.com/infused/dbf/blob/master/docs/supported_encodings.csv

     * https://github.com/olemb/dbfread/blob/master/dbfread/codepages.py

     * https://joinup.ec.europa.eu/svn/gvsig-desktop/trunk/libraries/libFMap/src/com/iver/cit/gvsig/fmap/drivers/dbf/DbfEncodings.java

     */

    private static final short[] codePages = {

        0x01, 0x02, 0x03, 0x04,

        0x08, 0x09, 0x0a, 0x0b,

        0x0d, 0x0e, 0x0f, 0x10,

        0x11, 0x12, 0x13, 0x14,

        0x15, 0x16, 0x17, 0x18,

        0x19, 0x1a, 0x1b, 0x1c,

        0x1d, 0x1f, 0x22, 0x23,

        0x24, 0x25, 0x26, 0x37,

        0x40, 0x4d, 0x4e, 0x4f,

        0x50, 0x57, 0x58, 0x59,

        0x64, 0x65, 0x66, 0x67,

        0x68, 0x69, 0x6a, 0x6b,

        0x6c, 0x78, 0x79, 0x7a,

        0x7b, 0x7c, 0x7d, 0x7d,

        0x86, 0x87, 0x88, 0xc8,

        0xc9, 0xca, 0xcb, 0xcc};

    /**

     * Equivalent Java charset names to the code pages defined in

     * {@link #codePages}, using Java NIO Charset names (which differ

     * from JAVA IO names, see

     * https://docs.oracle.com/javase/8/docs/technotes/guides/intl/encoding.doc.html)

     */

    private static final String[] charsetNames = new String[]{

        "IBM437", "IBM850", "windows-1252", "x-MacRoman",

        "IBM865", "IBM437", "IBM850", "IBM437",

        "IBM437", "IBM850", "IBM437", "IBM850",

        "IBM437", "IBM850", "x-IBM943", "IBM850",

        "IBM437", "IBM850", "IBM865", "IBM437",

        "IBM437", "IBM850", "IBM437", "IBM863",

        "IBM850", "IBM852", "IBM852", "IBM852",

        "IBM860", "IBM850", "IBM866", "IBM850",

        "IBM852", "x-mswin-936", "x-IBM949", "IBM950",

        "x-IBM874", "windows-1252", "windows-1252", "windows-1252",

        "IBM852", "IBM866", "IBM865", "IBM861",

        // 0x68 and 0x69 are unofficial "Codepage 895 Kamenicky (Czech) MS-DOS" and "Codepage 620  Mazovia (Polish) MS-DOS",

        // but there is no Java equivalent

        // so we use CP437 which is the closest charset for the latin characters part

        "IBM437", "IBM437", "x-IBM737", "IBM857",

        "IBM863", "x-IBM950", "x-IBM949", "x-mswin-936",

        "x-IBM942", "x-IBM874", "windows-1255", "windows-1256",

        "x-IBM737", "IBM852", "IBM857", "windows-1250",

        "windows-1251", "windows-1254", "windows-1253", "windows-1257"};

    public DefaultCPGFile() {

        this.charsetName = null;

        this.source = null;

    }

    @Override

    public File getFile(File file) {

        File f = new File(FilenameUtils.removeExtension(file.getAbsolutePath()) + "." + FILE_EXTENSION);

        return f;

    }

    @Override

    public File getFile() {

        return source;

    }

    @Override

    public String getCharsetName() {

        return this.charsetName;

    }

    @Override

    public void setCharsetName(String charsetName) {

        this.charsetName = charsetName;

    }

    @Override

    public String toCharsetName(String codePageName) {

        if (codePageName.equals("UTF8")) {

            return "UTF-8";

        }

        if (codePageName.equals("SJIS")) {

            return "Shift_JIS";

        }

        if (StringUtils.isNumeric(codePageName)) {

            if (codePageName.startsWith("8859") && codePageName.length() > 4) {

                return "ISO-8859-" + codePageName.substring(4);

            }

            if (codePageName.startsWith("125") && codePageName.length() == 4) {

                return "windows-" + codePageName;

            }

            if (codePageName.length() == 3) {

                return "IBM-" + codePageName;

            }

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

                if (charsetNames[i].contains(codePageName)) {

                    return codePageName;

                }

            }

        }

        if (codePageName.equals("65001")) {

            return "UTF-8";

        }

        return codePageName;

    }

    /**

     * Gets the Java NIO charset name equivalent to the provided code page.

     * Gets null if the provided code page is not recognised

     * as a valid code

     *

     * @param codePage

     * @return

     */

    @Override

    public String toCharsetName(int codePage) {

        if (codePage != 0) {

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

                if (codePages[i] == codePage) {

                    return charsetNames[i];

                }

            }

        }

        return null;

    }

    @Override

    public String toCPGName(String charsetName) {

        if (charsetName.startsWith("windows-")

                || charsetName.startsWith("ISO-8859")

                || charsetName.startsWith("IBM-")

                || charsetName.startsWith("x-IBM")

                || charsetName.startsWith("x-mswin-")) {

            return charsetName.replaceAll("[^\\d]", "");

        }

        if (charsetName.equals("Shift_JIS")) {

            return "SJIS";

        }

        // For the rest of the charsets, we'll directly write the Java NIO Charset

        // Probably they will only be recognized by gvSIG, but it's better than nothing

        return charsetName;

    }

    /**

     * Returns the code page corresponding to the

     * provided charset name

     *

     * @param charsetName

     * @return The code page, or 0x00 if no equivalent code page was found for

     * the provided charsetName

     */

    @Override

    public int toCPG(String charsetName) {

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

            if (charsetNames[i].equals(charsetName)) {

                return codePages[i];

            }

        }

        // default

        return 0x00;

    }

    @Override

    public void read(File file) throws IOException {

        File f = this.getFile(file);

        if (f.exists()) {

            try {

                String theContents = FileUtils.readFileToString(f);

                theContents = StringUtils.trim(theContents);

                if (StringUtils.isNotEmpty(theContents)) {

                    String theCharset = toCharsetName(theContents);

                    this.charsetName = theCharset;

                    this.source = f.getAbsoluteFile();

                }

            } catch (IOException e) {

                logger.warn("Couldn't read " + FILE_EXTENSION + " file (" + f.getAbsolutePath() + ").", e);

                throw e;

            }

        }

    }

    @Override

    public void write(File file) throws IOException {

        File f = this.getFile(file);

        try {

            String export = toCPGName(this.charsetName) + "\n";

            FileUtils.writeStringToFile(f, export, "ISO-8859-1");

            this.source = f;

        } catch (Exception e) {

            logger.warn("Couldn't write " + FILE_EXTENSION + " file (" + f.getAbsolutePath() + ").", e);

            throw e;

        }

    }

}

package org.gvsig.basicformats.impl;

import java.io.File;

import java.io.IOException;

import org.apache.commons.io.FileUtils;

import org.apache.commons.io.FilenameUtils;

import org.apache.commons.lang3.StringUtils;

import org.cresques.cts.ICRSFactory;

import org.cresques.cts.IProjection;

import org.gvsig.basicformats.PRJFile;

import org.gvsig.fmap.crs.CRSFactory;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

public class DefaultPRJFile extends AbstractFormatFile implements PRJFile {

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

    private File source;

    private IProjection crs;

    public DefaultPRJFile() {

        this.source = null;

        this.crs = null;        

    }

    @Override

    public File getFile(File file) {

        File f = new File(FilenameUtils.removeExtension(file.getAbsolutePath())+"."+FILE_EXTENSION);

        return f;

    }

    @Override

    public File getFile() {

        return source;

    }

    @Override

    public IProjection getCRS() {

        return this.crs;

    }

    @Override

    public void setCRS(IProjection crs) {

        this.crs = crs;

    }

    @Override

    public void read(File file) throws IOException {

        File f = this.getFile(file);

        if (f.exists()) {

            try {

                String theContents = FileUtils.readFileToString(f);

                if (StringUtils.isNotEmpty(theContents)){

                    IProjection theCrs=CRSFactory.getCRSFactory().get(ICRSFactory.FORMAT_WKT_ESRI, theContents);

                    this.crs = theCrs;

                    this.source = f.getAbsoluteFile();

                }

            } catch (IOException e) {

                logger.warn("Couldn't read "+FILE_EXTENSION+" file ("+f.getAbsolutePath()+").",e);

                throw e;

            }

        }

    }

    @Override

    public void write(File file) throws IOException {

        File f = this.getFile(file);

        try {

            String export = crs.export(ICRSFactory.FORMAT_WKT_ESRI);

            if(export!=null){

                FileUtils.writeStringToFile(f, export);

                this.source = f;

            }

        } catch (Exception e) {

            logger.warn("Couldn't write "+FILE_EXTENSION+" file ("+f.getAbsolutePath()+").",e);

            throw e;

        }

    }

}

package org.gvsig.basicformats.impl;

import java.io.File;

import java.io.IOException;

import java.nio.ByteOrder;

import java.util.List;

import org.apache.commons.io.FileUtils;

import org.apache.commons.io.FilenameUtils;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.basicformats.HDRFile;

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.GeometryLocator;

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

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

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

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

public class DefaultHDRFile extends AbstractFormatFile implements HDRFile {

    // http://resources.esri.com/help/9.3/arcgisdesktop/com/gp_toolref/spatial_analyst_tools/esri_ascii_raster_format.htm

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

    private File source;

    private String comments;

    private int nrows = NONE;

    private int ncols = NONE;

    private int nbands = 1;

    private int nbits = 8;

    private String pixeltype;

    private String byteorder_word;

    private ByteOrder byteorder = ByteOrder.nativeOrder();

    private String layout = LAYOUT_BIL;

    private int skipbytes = 0;

    private double ulxmax = Double.NaN;

    private double ulymax = Double.NaN;

    private double xdim = Double.NaN;

    private double ydim = Double.NaN;

    private int bandrowbytes = NONE;

    private int totalrowbytes = NONE;

    private int bandgapbytes = 0;

    private boolean valid = false;

    private double nodata_value = Double.NaN;

    // X coordinate of the origin (by center or lower left corner of the cell).

    private double xllcorner = Double.NaN;

    // Y coordinate of the origin (by center or lower left corner of the cell).

    private double yllcorner = Double.NaN;

    private int cellsize = NONE;

    public DefaultHDRFile() {

        this.source = null;

    }

    @Override

    public File getFile(File file) {

        File f = new File(FilenameUtils.removeExtension(file.getAbsolutePath()) + "." + FILE_EXTENSION);

        return f;

    }

    @Override

    public File getFile() {

        return source;

    }

    @Override

    public void read(File file) throws IOException {

        File f = this.getFile(file);

        if (f.exists()) {

            try {

                List<String> lines = FileUtils.readLines(f);

                if (lines != null) {

                    this.source = f.getAbsoluteFile();

                    int lineno = 1;

                    for (String line : lines) {

                        String[] words = StringUtils.split(line.trim().toLowerCase());

                        try {

                            switch (words[0]) {

                                case "nrows":

                                    this.nrows = Integer.parseInt(words[1]);

                                    break;

                                case "ncols":

                                    this.ncols = Integer.parseInt(words[1]);

                                    break;

                                case "nbands":

                                    this.nbands = Integer.parseInt(words[1]);

                                    break;

                                case "nbits":

                                    this.nbits = Integer.parseInt(words[1]);

                                    break;

                                case "pixeltype":

                                    this.pixeltype = words[1];

                                    break;

                                case "byteorder":

                                    this.byteorder_word = words[1];

                                    break;

                                case "layout":

                                    this.layout = words[1];

                                    break;

                                case "skipbytes":

                                    this.skipbytes = Integer.parseInt(words[1]);

                                    break;

                                case "nodata_value":

                                    this.nodata_value = Double.parseDouble(words[1]);

                                    break;

                                case "cellsize":

                                    this.cellsize = Integer.parseInt(words[1]);

                                    break;

                                case "xllcorner":

                                case "xllcenter":

                                    this.xllcorner = Double.parseDouble(words[1]);

                                    break;

                                case "yllcorner":

                                case "yllcenter":

                                    this.yllcorner = Double.parseDouble(words[1]);

                                    break;

                                case "ulxmax":

                                    this.ulxmax = Double.parseDouble(words[1]);

                                    break;

                                case "ulymax":

                                    this.ulymax = Double.parseDouble(words[1]);

                                    break;

                                case "xdim":

                                    this.xdim = Double.parseDouble(words[1]);

                                    break;

                                case "ydim":

                                    this.ydim = Double.parseDouble(words[1]);

                                    break;

                                case "bandrowbytes":

                                    this.bandrowbytes = Integer.parseInt(words[1]);

                                    break;

                                case "totalrowbytes":

                                    this.totalrowbytes = Integer.parseInt(words[1]);

                                    break;

                                case "bandgapbytes":

                                    this.bandgapbytes = Integer.parseInt(words[1]);

                                    break;

                            }

                        } catch (NumberFormatException e) {

                            logger.warn("Can't parse keyword '" + words[0]

                                    + "' (value='" + words[1]

                                    + "', lineno=+" + lineno

                                    + ", file=" + f.getAbsoluteFile()

                                    + ").", e);

                        }

                        lineno++;

                    }

                    this.fixValues();

                }

            } catch (IOException e) {

                logger.warn("Couldn't read " + FILE_EXTENSION + " file (" + f.getAbsoluteFile() + ")", e);

                throw e;

            } catch (Exception e) {

                String msg = "Couldn't read " + FILE_EXTENSION + " file (" + f.getAbsoluteFile() + ")";

                logger.warn(msg, e);

                throw new IOException(msg, e);

            }

        }

    }

    private void fixValues() {

        @SuppressWarnings("LocalVariableHidesMemberVariable")

        boolean valid = true;

        if (this.pixeltype != null) {

            switch (this.pixeltype) {

                case "signedint":

                    this.nbits = 32;

                    break;

                case "byte_unsigned":

                    this.nbits = 8;

                    break;

            }

        }

        switch (this.getNbits()) {

            case 1:

            case 4:

                logger.warn("nbits keyword has a non supported value of " + this.getNbits() + " (" + this.source.getAbsolutePath() + ").");

                valid = false;

                break;

            case 8:

            case 16:

            case 32:

            case 64:

                break;

            default:

                logger.warn("nbits keyword has an invalid value of " + this.getNbits() + " (" + this.source.getAbsolutePath() + ").");

                this.nbits = 1;

                valid = false;

                break;

        }

        switch (this.getLayout()) {

            case LAYOUT_BIL:

            case LAYOUT_BIP:

            case LAYOUT_BSQ:

                break;

            default:

                logger.warn("layout keyword has an invalid value of '" + this.getLayout() + "' (" + this.source.getAbsolutePath() + ").");

                this.layout = LAYOUT_BIL;

                valid = false;

                break;

        }

        if( StringUtils.isEmpty(this.byteorder_word) ) {

            this.byteorder = ByteOrder.nativeOrder();

            if( this.byteorder == ByteOrder.BIG_ENDIAN ) {

                this.byteorder_word = "msbfirst";

            } else {

                this.byteorder_word = "lsbfirst";

            }

        } else {

            switch(this.byteorder_word) {

                case "lsbfirst":

                case "little_endian":

                case "littleendian":

                case "intel":

                case "i":

                    this.byteorder = ByteOrder.LITTLE_ENDIAN;

                    break;

                case "motorola":

                case "m":

                case "msbfirst":

                case "big_endian":

                case "bigendian":

                    this.byteorder = ByteOrder.BIG_ENDIAN;

                    break;

                default:

                    logger.warn("byteorder keyword has an invalid value of '" + this.byteorder_word + "' (" + this.source.getAbsolutePath() + ").");

                    this.byteorder = ByteOrder.nativeOrder();

            }

        }

        if (this.getNrows() == NONE || this.getNcols() == NONE) {

            logger.warn("nrows/ncols keywords has an invalid value of '" + this.getNrows() + "/" + this.getNcols() + "' (" + this.source.getAbsolutePath() + ").");

            valid = false;

        }

        if (this.getUlymax() == NONE) {

            this.ulymax = this.getNrows() - 1;

        }

        if (this.getBandrowbytes() == NONE) {

            this.bandrowbytes = (this.getNcols() * this.getNbits()) / 8;

        }

        switch (this.getLayout()) {

            case LAYOUT_BIL:

                if (this.getTotalrowbytes() == NONE) {

                    this.totalrowbytes = this.getNbands() * this.getBandrowbytes();

                }

                this.bandgapbytes = 0;

                break;

            case LAYOUT_BIP:

                if (this.getTotalrowbytes() == NONE) {

                    this.totalrowbytes = (this.getNcols() * this.getNbands() * this.getNbits()) / 8;

                }

                this.bandgapbytes = 0;

                break;

            case LAYOUT_BSQ:

                if (this.getTotalrowbytes() == NONE) {

                    this.totalrowbytes = 0;

                }

                if (this.getBandgapbytes() == NONE) {

                    this.bandgapbytes = 0;

                }

                break;

        }

        this.valid = valid;

    }

    @Override

    public int getDataType() {

        if (this.pixeltype != null) {

            switch (this.pixeltype) {

                case "signedint":

                    return BufferManager.TYPE_INT;

                case "byte_unsigned":

                    return BufferManager.TYPE_BYTE;

            }

        }

        switch (this.getNbits()) {

            case 1:

            case 4:

            default:

                return BufferManager.TYPE_UNDEFINED;

            case 8:

                return BufferManager.TYPE_BYTE;

            case 16:

                return BufferManager.TYPE_USHORT;

            case 32:

                return BufferManager.TYPE_INT;

            case 64:

                return BufferManager.TYPE_DOUBLE;

        }

    }

    @Override

    public void write(File file) throws IOException {

        File f = this.getFile(file);

        StringBuilder builder = new StringBuilder();

        builder.append("; ").append(this.comments).append("\n");

        builder.append("nrows ").append(this.nrows).append("\n");

        builder.append("ncols ").append(this.ncols).append("\n");

        builder.append("nbands ").append(this.nbands).append("\n");

        builder.append("nbits ").append(this.nbits).append("\n");

        builder.append("layout ").append(LAYOUT_BSQ).append("\n");

        builder.append("byteorder ").append(this.byteorder_word).append("\n");

        builder.append("ulxmax ").append(this.ulxmax).append("\n");

        builder.append("ulymax ").append(this.ulymax).append("\n");

        builder.append("ydim ").append(this.ydim).append("\n");

        builder.append("xdim ").append(this.xdim).append("\n");

        FileUtils.write(file, builder.toString());

    }

    @Override

    public void setByteOrder(ByteOrder order) {

        this.byteorder = order;

        if( order == ByteOrder.BIG_ENDIAN ) {

            this.byteorder_word = "msbfirst";

        } else {

            this.byteorder_word = "lsbfirst";

        }

    }

    @Override

    public void setNBands(int nbands) {

        this.nbands = nbands;

    }

    @Override

    public void setDataType(int dataType) {

        switch(dataType) {

            case BufferManager.TYPE_BYTE:

                this.nbits = 8;

                break;

            case BufferManager.TYPE_USHORT:

                this.nbits = 16;

                break;

            case BufferManager.TYPE_INT:

                this.nbits = 32;

                break;

            case BufferManager.TYPE_DOUBLE:

                this.nbits = 64;

                break;

            default:

                throw new IllegalArgumentException("The data type "+dataType +" is not supported");

        }

    }

    @Override

    public void setDimensions(int nrows, int ncols, Envelope envelope) {

        this.ncols = ncols;

        this.nrows = nrows;

        Point min = envelope.getLowerCorner();

        Point max = envelope.getUpperCorner();

        this.ulxmax = min.getX();

        this.ulymax = max.getY();

        this.ydim = (min.getY() - max.getY()) / this.nrows;

        this.xdim = (max.getX() - min.getX()) / this.ncols;

    }

    @Override

    public Envelope getEnvelope() {

        Envelope envelope = null;

        try {

            if (!Double.isNaN(this.xllcorner)

                    && !Double.isNaN(this.yllcorner)

                    && this.cellsize > 0) {

                envelope = GeometryLocator.getGeometryManager().createEnvelope(

                        this.xllcorner,

                        this.yllcorner,

                        this.xllcorner + (this.ncols * this.cellsize),

                        this.yllcorner + (this.nrows * this.cellsize),

                        Geometry.SUBTYPES.GEOM2D);

            }

            if (envelope == null && !Double.isNaN(this.ulxmax)

                    && !Double.isNaN(this.ulymax)

                    && !Double.isNaN(this.xdim)

                    && !Double.isNaN(this.ydim)) {

                envelope = GeometryLocator.getGeometryManager().createEnvelope(

                        this.ulxmax,

                        this.ulymax - (this.nrows * this.ydim),

                        this.ulxmax + (this.ncols * this.xdim),

                        this.ulymax,

                        Geometry.SUBTYPES.GEOM2D);

            }

            if (envelope == null && !Double.isNaN(this.xdim)

                    && !Double.isNaN(this.ydim)) {

                envelope = GeometryLocator.getGeometryManager().createEnvelope(

                        0,

                        0,

                        this.ncols * this.xdim,

                        this.nrows * this.ydim,

                        Geometry.SUBTYPES.GEOM2D);

            }

            if (envelope == null && this.cellsize > 0) {

                envelope = GeometryLocator.getGeometryManager().createEnvelope(

                        0,

                        0,

                        this.ncols * this.cellsize,

                        this.nrows * this.cellsize,

                        Geometry.SUBTYPES.GEOM2D);

            }

            if (envelope == null) {

                envelope = GeometryLocator.getGeometryManager().createEnvelope(

                        0,

                        0,

                        this.ncols,

                        this.nrows,

                        Geometry.SUBTYPES.GEOM2D);

            }

        } catch (Exception ex) {

            logger.debug("Can't calculate envelope.", ex);

        }

        return envelope;

    }

    /**

     * @return the nrows

     */

    @Override

    public int getNrows() {

        return nrows;

    }

    /**

     * @return the ncols

     */

    @Override

    public int getNcols() {

        return ncols;

    }

    /**

     * @return the nbands

     */

    @Override

    public int getNbands() {

        return nbands;

    }

    /**

     * @return the nbits

     */

    @Override

    public int getNbits() {

        return nbits;

    }

    /**

     * @return the byteorder

     */

    @Override

    public ByteOrder getByteorder() {

        return byteorder;

    }

    /**

     * @return the layout

     */

    @Override

    public String getLayout() {

        return layout;

    }

    /**

     * @return the skipbytes

     */

    @Override

    public int getSkipbytes() {

        return skipbytes;

    }

    /**

     * @return the ulxmax

     */

    @Override

    public double getUlxmax() {

        return ulxmax;

    }

    /**

     * @return the ulymax

     */

    @Override

    public double getUlymax() {

        return ulymax;

    }

    /**

     * @return the xdim

     */

    @Override

    public double getXdim() {

        return xdim;

    }

    /**

     * @return the ydim

     */

    @Override

    public double getYdim() {

        return ydim;

    }

    /**

     * @return the bandrowbytes

     */

    @Override

    public int getBandrowbytes() {

        return bandrowbytes;

    }

    /**

     * @return the totalrowbytes

     */

    @Override

    public int getTotalrowbytes() {

        return totalrowbytes;

    }

    /**

     * @return the bandgapbytes

     */

    @Override

    public int getBandgapbytes() {

        return bandgapbytes;

    }

    /**

     * @return the isValid

     */

    @Override

    public boolean isValid() {

        return valid;

    }

    /**

     * @return the comments

     */

    @Override

    public String getComments() {

        return comments;

    }

    /**

     * @param comments the comments to set

     */

    @Override

    public void setComments(String comments) {

        this.comments = comments;

    }

    /**

     * @return the nodata_value

     */

    @Override

    public double getNodata_value() {

        return nodata_value;

    }

    /**

     * @return the xllcorner

     */

    @Override

    public double getXllcorner() {

        return xllcorner;

    }

    /**

     * @return the yllcorner

     */

    @Override

    public double getYllcorner() {

        return yllcorner;

    }

    /**

     * @return the cellsize

     */

    @Override

    public int getCellsize() {

        return cellsize;

    }

    @Override

    public int getBandSize() {

        return (this.nrows * this.ncols * this.nbits) + this.bandgapbytes;

    }

}

package org.gvsig.basicformats.impl;

import java.io.File;

import java.io.IOException;

import java.util.ArrayList;

import java.util.Collections;

import java.util.List;

import org.apache.commons.io.FileUtils;

import org.apache.commons.io.FilenameUtils;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.basicformats.STXFile;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

public class DefaultSTXFile extends AbstractFormatFile implements STXFile {

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

    private File source;

    private List<STXBand> bands;

    public static class DefaultSTXBand implements STXBand {

        private int band;

        private double minimum;

        private double maximum;

        private double mean; // Optional

        private double std_deviation; // Optional

        private double linear_stretch_min; // Optional

        private double linear_stretch_max; // Optional

        private boolean valid = false;

        public DefaultSTXBand() {

        }

        public DefaultSTXBand(

            int band,

            double minimum,

            double maximum,

            double mean,

            double std_deviation,

            double linear_stretch_min,

            double linear_stretch_max

            ) {

            this();

            this.band = band;

            this.minimum = minimum;

            this.maximum = maximum;

            this.mean = mean;

            this.std_deviation = std_deviation;

            this.linear_stretch_min = linear_stretch_min;

            this.linear_stretch_max = linear_stretch_max;

        }

        @SuppressWarnings("OverridableMethodCallInConstructor")

        public DefaultSTXBand(String line) {

            this();

            this.parse(line);

        }

        @Override

        public void parse(String line) {

            valid = false;

            String[] words = StringUtils.split(line.trim().toLowerCase());

            if( words.length < 7 ) {

                throw new IllegalArgumentException("At least 7 parameters are needed ("+line+").");

            }

            this.band = Integer.parseInt(words[0]);

            this.minimum = Double.parseDouble(words[1]);

            this.maximum = Double.parseDouble(words[2]);

            if( "#".equals(words[3]) ) {

                this.mean = Double.NaN;

            } else {

                this.mean = Double.parseDouble(words[3]);

            }

            if( "#".equals(words[4]) ) {

                this.std_deviation = Double.NaN;

            } else {

                this.std_deviation = Double.parseDouble(words[4]);

            }

            if( "#".equals(words[5]) ) {

                this.linear_stretch_min = Double.NaN;

            } else {

                this.linear_stretch_min = Double.parseDouble(words[5]);

            }

            if( "#".equals(words[6]) ) {

                this.linear_stretch_max = Double.NaN;

            } else {

                this.linear_stretch_max = Double.parseDouble(words[6]);

            }

            valid = true;

        }

        @Override

        public String toString() {

            StringBuilder builder = new StringBuilder();

            builder.append(this.band).append(" ");

            builder.append(this.minimum).append(" ");

            builder.append(this.maximum).append(" ");

            if( Double.isNaN(this.mean) ) {

                builder.append("# ");

            } else {

                builder.append(this.mean).append(" ");

            }

            if( Double.isNaN(this.std_deviation) ) {

                builder.append("# ");

            } else {

                builder.append(this.std_deviation).append(" ");

            }

            if( Double.isNaN(this.linear_stretch_min) ) {

                builder.append("# ");

            } else {

                builder.append(this.linear_stretch_min).append(" ");

            }

            if( Double.isNaN(this.linear_stretch_max) ) {

                builder.append("# ");

            } else {

                builder.append(this.linear_stretch_max).append(" ");

            }

            return builder.toString();

        }

        @Override

        public int getBand() {

            return band;

        }

        @Override

        public double getMinimum() {

            return minimum;

        }

        @Override

        public double getMaximum() {

            return maximum;

        }

        @Override

        public double getMean() {

            return mean;

        }

        @Override

        public double getStdDeviation() {

            return std_deviation;

        }

        @Override

        public double getLinearStretchMin() {

            return linear_stretch_min;

        }

        @Override

        public double getLinearStretchMax() {

            return linear_stretch_max;

        }

        @Override

        public boolean isValid() {

            return valid;

        }

    }

   public DefaultSTXFile() {

        this.source = null;

        this.bands = new ArrayList<>();

    }

    @Override

    public File getFile(File file) {

        File f = new File(FilenameUtils.removeExtension(file.getAbsolutePath())+"."+FILE_EXTENSION);

        return f;

    }

    @Override

    public File getFile() {

        return source;

    }

    @Override

    public void read(File file) throws IOException {

        File f = this.getFile(file);

        if (f.exists()) {

            try {

                this.bands = new ArrayList<>();

                List<String> lines = FileUtils.readLines(f);

                if (lines != null) {

                    this.source = f.getAbsoluteFile();

                    int lineno = 1;

                    for (String line : lines) {

                        try {

                            DefaultSTXBand band = new DefaultSTXBand(line.trim());

                            this.bands.add(band);

                        } catch(IllegalArgumentException e) {

                            logger.warn("Can't parse line '" + line

                                    + "' (lineno=+" + lineno

                                    + ", file=" + f.getAbsoluteFile()

                                    + ").", e);

                        }

                    }

                }

                this.bands = Collections.unmodifiableList(this.bands);

            } catch (IOException e) {

                logger.warn("Couldn't read "+FILE_EXTENSION+" file (" + f.getAbsoluteFile() + ")", e);

                throw e;

            }

        }

    }

    @Override

    public List<STXBand> getBands() {

        return this.bands;

    }

    @Override

    public void clear() {

        this.bands = new ArrayList<>();

    }

    @Override

    public void addBand(

            int band,

            double minimum,

            double maximum,

            double mean,

            double std_deviation,

            double linear_stretch_min,

            double linear_stretch_max

        ) {

        DefaultSTXBand b = new DefaultSTXBand(band, minimum, maximum, mean, std_deviation, linear_stretch_min, linear_stretch_max);

        this.bands.add(b);

    }

    @Override

    public void write(File file) throws IOException {

        File f = this.getFile(file);

        List<String> lines = new ArrayList<>();

        for (STXBand band : this.bands) {

            lines.add(band.toString());

        }

        FileUtils.writeLines(f, lines);

        this.source = f;

    }

}

package org.gvsig.basicformats.impl;

import java.awt.Color;

import java.io.File;

import java.io.IOException;

import java.util.ArrayList;

import java.util.List;

import org.apache.commons.io.FileUtils;

import org.apache.commons.io.FilenameUtils;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.basicformats.CLRFile;

import org.gvsig.raster.lib.legend.api.RasterLegendLocator;

import org.gvsig.raster.lib.legend.api.RasterLegendManager;

import org.gvsig.raster.lib.legend.api.colortable.ColorTable;

import org.gvsig.raster.lib.legend.api.colortable.colortableclass.ColorTableClass;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

public class DefaultCLRFile extends AbstractFormatFile implements CLRFile {

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

    private File source;

    private ColorTable colorTable;

    public DefaultCLRFile() {

        this.source = null;

        this.colorTable = null;

    }

    @Override

    public File getFile(File file) {

        File f = new File(FilenameUtils.removeExtension(file.getAbsolutePath()) + "." + FILE_EXTENSION);

        return f;

    }

    @Override

    public File getFile() {

        return source;

    }

    @Override

    public ColorTable getColorTable() {

        return this.colorTable;

    }

    @Override

    public void setColorTable(ColorTable colorTable) {

        this.colorTable = colorTable;

    }

    @Override

    public void read(File file) throws IOException {

        File f = this.getFile(file);

        if (f.exists()) {

            try {

                RasterLegendManager legendManager = RasterLegendLocator.getRasterLegendManager();

                List<ColorTableClass> colors = new ArrayList<>();

                List<String> lines = FileUtils.readLines(f);

                if (lines != null) {

                    this.source = f.getAbsoluteFile();

                    int lineno = 1;

                    double interpolation = 50.0;

                    for (String line : lines) {

                        line = line.trim();

                        if (!Character.isDigit(line.charAt(0))) {

                            continue;

                        }

                        try {

                            String[] words = StringUtils.split(line);

                            if (words.length < 4) {

                                continue;

                            }

                            int value = Integer.parseInt(words[0]);

                            int r = Integer.parseInt(words[1]);

                            int g = Integer.parseInt(words[2]);

                            int b = Integer.parseInt(words[3]);

                            Color color = new Color(r, g, b);

                            ColorTableClass colorTableClass = legendManager.createColorTableClass(

                                    String.valueOf(value), value, interpolation, color);

                            colors.add(colorTableClass);

                        } catch (Exception e) {

                            logger.warn("Can't parse line '" + line

                                    + "' (lineno=+" + lineno

                                    + ", file=" + f.getAbsoluteFile()

                                    + ").", e);

                        }

                    }

                }

                if( !colors.isEmpty() ) {

                    String colorTableName = FilenameUtils.getBaseName(f.getName());

                    this.colorTable = legendManager.createColorTable(colorTableName, colors, true);

                }

            } catch (IOException e) {

                logger.warn("Couldn't read " + FILE_EXTENSION + " file (" + f.getAbsoluteFile() + ")", e);

                throw e;

            }

        }

    }

    @Override

    public void write(File file) throws IOException {

        File f = this.getFile(file);

        // TODO: falta implementar guardar la CLR

    }

}

package org.gvsig.basicformats.impl;

import java.io.File;

import java.io.IOException;

import java.util.List;

import org.apache.commons.io.FileUtils;

import org.apache.commons.io.FilenameUtils;

import org.gvsig.basicformats.WLDFile;

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.GeometryLocator;

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

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

public class DefaultWLDFile extends AbstractFormatFile implements WLDFile {

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

    private File source;

    private double pixelSizeX;

    private double rotationAxisY;

    private double rotationAxisX;

    private double pixelSizeY;

    private double upperLeftPixelCenterCoordX;

    private double upperLeftPixelCenterCoordY;

    public DefaultWLDFile() {

        this.source = null;

    }

    @Override

    public File getFile(File file) {

        File f = new File(FilenameUtils.removeExtension(file.getAbsolutePath())+"."+FILE_EXTENSION);

        return f;

    }

    @Override

    public File getFile() {

        return source;

    }

    @Override

    public void read(File file) throws IOException {

        File f = this.getFile(file);

        if (f.exists()) {

            try {

                List<String> lines = FileUtils.readLines(f);

                if (lines!=null ) {

                    this.source = f.getAbsoluteFile();

                    int lineno = 0;

                    for (String line : lines) {

                        line = line.trim();

                        char ch = line.charAt(0);

                        if( lineno>5 || Character.isLetter(ch) || ch==';' || ch=='#' ) {

                            continue;

                        }

                        try {

                            double value = Double.parseDouble(line);

                            switch(lineno) {

                                case 0:

                                    this.pixelSizeX=value;

                                    break;

                                case 1:

                                    this.rotationAxisY = value;

                                    break;

                                case 2:

                                    this.rotationAxisX = value;

                                    break;

                                case 3:

                                    this.pixelSizeY = value;

                                    break;

                                case 4:

                                    this.upperLeftPixelCenterCoordX = value;

                                    break;

                                case 5:

                                    this.upperLeftPixelCenterCoordY = value;

                                    break;

                            }

                            lineno++;

                        } catch(NumberFormatException e) {

                        }

                    }

                }

            } catch (IOException e) {

                logger.warn("Couldn't read "+FILE_EXTENSION+" file ("+f.getAbsolutePath()+").",e);

                throw e;

            }

        }

    }

    @Override

    public Envelope getEnvelope(int rows, int columns) {

        Envelope envelope = null;

        if (0.0 != getRotationAxisX() || 0.0 != getRotationAxisY()) {

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

        }

        double leftMostX = 0;

        double upperMostY = 0;

        double height = 0;

        double width = 0;

        try {

            leftMostX = getUpperLeftPixelCenterCoordX() - (getPixelSizeX() * 0.5);

            upperMostY = getUpperLeftPixelCenterCoordY() - (getPixelSizeY() * 0.5);

            height=rows*getPixelSizeY();

            width=columns*getPixelSizeX();

            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 (Exception e) {

            logger.warn(

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

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

        }

        return envelope;        

    }

    @Override

    public void write(File file) {

        // TODO: Falta implementar el write del WLDFile

        File f = this.getFile(file);

    }

    @Override

    public void setValue(Envelope envelope, int rows, int columns) {

        // TODO: Falta implementar el setValue del WLDFile

    }

    /**

     * @return the pixelSizeX

     */

    @Override

    public double getPixelSizeX() {

        return pixelSizeX;

    }

    /**

     * @return the rotationAxisY

     */

    @Override

    public double getRotationAxisY() {

        return rotationAxisY;

    }

    /**

     * @return the rotationAxisX

     */

    @Override

    public double getRotationAxisX() {

        return rotationAxisX;

    }

    /**

     * @return the pixelSizeY

     */

    @Override

    public double getPixelSizeY() {

        return pixelSizeY;

    }

    /**

     * @return the upperLeftPixelCenterCoordX

     */

    @Override

    public double getUpperLeftPixelCenterCoordX() {

        return upperLeftPixelCenterCoordX;

    }