Application: gvSIG desktop

/**

 * gvSIG. Desktop Geographic Information System.

 *

 * Copyright (C) 2007-2013 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 3 of the License, or (at your option) any later

 * version.

 *

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

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS

 * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more

 * details.

 *

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

 * this program; if not, write to the Free Software Foundation, Inc., 51

 * Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.

 *

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

 * gvsig.com, or visit our website www.gvsig.com.

 */

package org.gvsig.fmap.dal.store.shp.utils;

import java.io.BufferedReader;

import java.io.File;

import java.io.FileInputStream;

import java.io.FileReader;

import java.io.IOException;

import java.nio.ByteOrder;

import java.nio.channels.FileChannel;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

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

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

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

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

import org.gvsig.fmap.dal.store.shp.SHPStoreParameters;

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.Geometry.SUBTYPES;

import org.gvsig.fmap.geom.Geometry.TYPES;

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.primitive.Envelope;

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

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

import org.gvsig.fmap.geom.type.GeometryType;

import org.gvsig.fmap.geom.type.GeometryTypeNotSupportedException;

import org.gvsig.fmap.geom.type.GeometryTypeNotValidException;

import org.gvsig.tools.exception.BaseException;

import org.gvsig.utils.bigfile.BigByteBuffer2;

/**

 * @author jmvivo

 *

 */

public class SHPFile2 implements ISHPFile {

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

    private Envelope extent;

    private int type;

    private int subType;

    private String srsParameters;

    private FileInputStream fin;

    private FileChannel channel;

    private BigByteBuffer2 bb;

    private FileInputStream finShx;

    private FileChannel channelShx;

    private BigByteBuffer2 bbShx;

    private SHPStoreParameters params;

    private int[] supportedGeometryTypes;

    private final GeometryManager gManager = GeometryLocator

        .getGeometryManager();

    private GeometryType gtypeNull;

    private PointGeometryType gtypePoint2D;

    private GeometryType gtypeCurve2D;

    private GeometryType gtypeSurface2D;

    private GeometryType gtypeMultiPoint2D;

    private boolean useNullGeometry = false;

    private SHPReader reader;

    public SHPFile2(SHPStoreParameters params) {

        this.params = params;

        try {

            gtypeNull = gManager.getGeometryType(TYPES.NULL, SUBTYPES.GEOM2D);

            gtypePoint2D

                    = (PointGeometryType) gManager.getGeometryType(TYPES.POINT,

                    SUBTYPES.GEOM2D);

            gtypeCurve2D

                    = gManager.getGeometryType(TYPES.CURVE, SUBTYPES.GEOM2D);

            gtypeSurface2D

                    = gManager.getGeometryType(TYPES.SURFACE, SUBTYPES.GEOM2D);

            gtypeMultiPoint2D

                    = gManager.getGeometryType(TYPES.MULTIPOINT, SUBTYPES.GEOM2D);

        } catch (GeometryTypeNotSupportedException e) {

            throw new RuntimeException(

                "Unable to get the 2D geometry types to use", e);

        } catch (GeometryTypeNotValidException e) {

            throw new RuntimeException(

                "Unable to get the 2D geometry types to use", e);

        }

    }

    public void setUseNullGeometry(boolean useNullGeometry) {

        this.useNullGeometry = useNullGeometry;

    }

    /*

     * (non-Javadoc)

     *

     * @see org.gvsig.fmap.dal.Resource#doClose()

     */

    public void close() throws CloseException {

        CloseException ret = null;

        logger.debug("Closing shp/shx file '"+this.params.getSHPFileName()+"'");

        // FIXME: Arreglar esto para que se acumulen los errores

        try {

            channel.close();

            channelShx.close();

        } catch (IOException e) {

            ret = new CloseException("SHPFile.close", e);

        } finally {

            try {

                fin.close();

                finShx.close();

            } catch (IOException e1) {

                ret = new CloseException("SHPFile.close", e1);

            }

        }

        if (ret != null) {

            throw ret;

        }

        bb = null;

        bbShx = null;

        fin = null;

        finShx = null;

        channel = null;

        channelShx = null;

        srsParameters = null;

    }

    public boolean isOpen() {

        return this.fin != null;

    }

    public synchronized void open() throws DataException {

        try {

            fin = new FileInputStream(this.params.getSHPFile());

        } catch (java.io.FileNotFoundException e) {

            throw new FileNotFoundException(this.params.getSHPFileName());

        }

        // Open the file and then get a channel from the stream

        channel = fin.getChannel();

        // long size = channel.size();

        // Get the file's size and then map it into memory

        // bb = channel.map(FileChannel.MapMode.READ_ONLY, 0, size);

        try {

            bb = new BigByteBuffer2(channel, FileChannel.MapMode.READ_ONLY);

        } catch (IOException e) {

            throw new ReadException(this.params.getSHPFileName(), e);

        }

        try {

            finShx = new FileInputStream(this.params.getSHXFile());

        } catch (java.io.FileNotFoundException e) {

            throw new FileNotFoundException(this.params.getSHXFileName());

        }

        // Open the file and then get a channel from the stream

        channelShx = finShx.getChannel();

        // long sizeShx = channelShx.size();

        // Get the file's size and then map it into memory

        // bb = channel.map(FileChannel.MapMode.READ_ONLY, 0, size);

        // bbShx = channelShx.map(FileChannel.MapMode.READ_ONLY, 0, sizeShx);

        try {

            bbShx

                    = new BigByteBuffer2(channelShx, FileChannel.MapMode.READ_ONLY);

        } catch (IOException e) {

            throw new ReadException(this.params.getSHXFileName(), e);

        }

        bbShx.order(ByteOrder.BIG_ENDIAN);

        // create a new header.

        ShapeFileHeader2 myHeader = new ShapeFileHeader2();

        bb.position(0);

        // read the header

        myHeader.readHeader(bb);

        double[] min = new double[2];

        min[0] = myHeader.myXmin;

        min[1] = myHeader.myYmin;

        double[] max = new double[2];

        max[0] = myHeader.myXmax;

        max[1] = myHeader.myYmax;

        try {

            extent =

                gManager.createEnvelope(min[0], min[1], max[0], max[1],

                    SUBTYPES.GEOM2D);

        } catch (CreateEnvelopeException e1) {

            logger.warn("Error creating the envelope", e1);

        }

        // extent = new Rectangle2D.Double(myHeader.myXmin, myHeader.myYmin,

        // myHeader.myXmax - myHeader.myXmin,

        // myHeader.myYmax - myHeader.myYmin);

        type = myHeader.myShapeType;

        subType = getGeometrySubType();

        switch (subType) {

        case SUBTYPES.GEOM2D:

            reader = new SHPReader2D(this.params);

            break;

        case SUBTYPES.GEOM2DM:

            reader = new SHPReader2DM(this.params);

            break;

        case SUBTYPES.GEOM3DM:

            reader = new SHPReader3DM(this.params);

            break;

        default:

            break;

        }

        this.initSupportedGeometryTypes();

        double x = myHeader.myXmin;

        double y = myHeader.myYmin;

        double w = myHeader.myXmax - myHeader.myXmin;

        double h = myHeader.myYmax - myHeader.myYmin;

        if (w == 0) {

            x -= 0.1;

            w = 0.2;

        }

        if (h == 0) {

            y -= 0.1;

            h = 0.2;

        }

        // TODO: SRS

        File prjFile = SHP.getPrjFile(this.params.getSHPFile());

        if (prjFile.exists()) {

            BufferedReader input = null;

            try {

                input = new BufferedReader(new FileReader(prjFile));

            } catch (java.io.FileNotFoundException e) {

                throw new FileNotFoundException(prjFile.getAbsolutePath());

            }

            try {

                this.srsParameters = input.readLine();

            } catch (IOException e) {

                throw new ReadException("SHPFile.open prj", e);

            } finally {

                try {

                    input.close();

                } catch (IOException e) {

                    // TODO ???

                }

            }

        } else {

            this.srsParameters = null;

        }

    }

    public Envelope getFullExtent() throws ReadException {

        return this.extent;

    }

    public boolean isEditable() {

        return this.params.getDBFFile().canWrite()

            && this.params.getSHPFile().canWrite()

            && this.params.getSHXFile().canWrite();

    }

    public int getGeometryType() throws ReadException {

        int auxType = 0;

        switch (type) {

        case (SHP.POINT2D):

        case (SHP.POINT3D):

        case (SHP.POINTM):

            auxType = auxType | Geometry.TYPES.POINT;

            break;

        case (SHP.POLYLINE2D):

        case (SHP.POLYLINE3D):

        case (SHP.POLYLINEM):

            auxType = auxType | Geometry.TYPES.MULTICURVE;

            break;

        case (SHP.POLYGON2D):

        case (SHP.POLYGON3D):

        case (SHP.POLYGONM):

            auxType = auxType | Geometry.TYPES.MULTISURFACE;

            break;

        case (SHP.MULTIPOINT2D):

        case (SHP.MULTIPOINT3D):

        case (SHP.MULTIPOINTM):

            auxType = auxType | Geometry.TYPES.MULTIPOINT;

            break;

        }

        return auxType;

    }

    public int getGeometrySubType() throws ReadException {

        switch (type) {

        case (SHP.POINT2D):

        case (SHP.POLYLINE2D):

        case (SHP.POLYGON2D):

        case (SHP.MULTIPOINT2D):

            return SUBTYPES.GEOM2D;

        case (SHP.POINT3D):

        case (SHP.POLYLINE3D):

        case (SHP.POLYGON3D):

        case (SHP.MULTIPOINT3D):

            return SUBTYPES.GEOM3DM;

        case (SHP.POINTM):

        case (SHP.POLYLINEM):

        case (SHP.POLYGONM):

        case (SHP.MULTIPOINTM):

            return SUBTYPES.GEOM2DM;

        }

        return SUBTYPES.UNKNOWN;

    }

    public Geometry getNullGeometry() throws CreateGeometryException {

        if (this.useNullGeometry) {

            return gtypeNull.create();

        }

        return null;

    }

    /**

     * Gets the geometry with the index provided. Set to synchronized to prevent

     * concurrent threads issue (?)

     *

     * @param position

     * @return

     * @throws ReadException

     * @throws CreateGeometryException

     */

    public synchronized Geometry getGeometry(long position)

        throws ReadException, CreateGeometryException {

        int shapeType;

        bb.position(getPositionForRecord(position));

        bb.order(ByteOrder.LITTLE_ENDIAN);

        shapeType = bb.getInt();

        if (shapeType == SHP.NULL) {

            return getNullGeometry();

        }

        /*

         * Inconsistency: this particular shape is not

         * of the expected type. This can be because the SHP file

         * is corrupt and it can cause "out of memory error"

         * because the code will possibly try to instantiate a

         * huge (absurd) array, so it's safer to return a null geometry

         */

        if (shapeType != type) {

            if( ! this.params.getAllowInconsistenciesInGeometryType() ) {

                throw new InconsistenciesInGeometryTypeException(shapeType);

            }

        }

        // retrieve that shape.

        switch (type) {

        case (SHP.POINT2D):

        case (SHP.POINT3D):

        case (SHP.POINTM):

            return reader.readPoint(bb);

        case (SHP.POLYLINE2D):

        case (SHP.POLYLINE3D):

        case (SHP.POLYLINEM):

            return reader.readPoLyline(bb);

        case (SHP.POLYGON2D):

        case (SHP.POLYGON3D):

        case (SHP.POLYGONM):

            try {

                return reader.readPoLygon(bb);

            } catch (BaseException e) {

                throw new CreateGeometryException(Geometry.TYPES.POLYGON, getGeometrySubType(), e);

            }

        case (SHP.MULTIPOINT2D):

        case (SHP.MULTIPOINTM):

        case (SHP.MULTIPOINT3D):

            return reader.readMultiPoint(bb);

        }

        return null;

    }

    private class InconsistenciesInGeometryTypeException extends ReadException {

        private final static String MESSAGE_FORMAT = "The geometry type  (%(geomTypeOfHeader)) of the shape file (%(fname)) does not match the type of the current geometry (%(geomTypeOfGeometry)).\nCheck 'Allow inconsistencies in geometry type' in the shape's properties of the add layer dialog to ignore it.";

        private final static String MESSAGE_KEY = "_InconsistenciesInGeometryTypeException";

        private static final long serialVersionUID = 8991813814092628916L;

        public InconsistenciesInGeometryTypeException(int geomTypeOfGeometry) {

            super(MESSAGE_FORMAT, null, MESSAGE_KEY, serialVersionUID);

            setValue("geomTypeOfHeader", SHP.getTypeName(type));

            setValue("geomTypeOfGeometry", SHP.getTypeName(geomTypeOfGeometry));

            setValue("fname", params.getSHPFile().getName());

        }

    }

    private long getPositionForRecord(long numRec) {

        // shx file has a 100 bytes header, then, records

        // 8 bytes length, one for each entity.

        // first 4 bytes are the offset

        // next 4 bytes are length

        int posIndex = 100 + ((int) numRec * 8);

        // bbShx.position(posIndex);

        long pos = 8 + 2 * bbShx.getInt(posIndex);

        return pos;

    }

    /**

     * Reads the Point from the shape file.

     *

     * @param in ByteBuffer.

     *

     * @return Point2D.

     * @throws ReadException

     * @throws CreateGeometryException

     */

    private Point readPoint(BigByteBuffer2 in)

        throws CreateGeometryException, ReadException {

        return readPoint(subType, in);

    }

    private Point readPoint(int subtype, BigByteBuffer2 in)

            throws CreateGeometryException, ReadException {

        // bytes 1 to 4 are the type and have already been read.

        // bytes 4 to 12 are the X coordinate

        in.order(ByteOrder.LITTLE_ENDIAN);

        double x = in.getDouble();

        double y = in.getDouble();

        Point p = gManager.createPoint(x, y, subtype);

        return p;

    }

    /**

     * Lee un rect?ngulo del fichero.

     *

     * @param in ByteBuffer.

     *

     * @return Rect?ngulo.

     * @throws CreateEnvelopeException

     *

     * @throws IOException

     */

    private Envelope readRectangle(BigByteBuffer2 in)

        throws CreateEnvelopeException {

        in.order(ByteOrder.LITTLE_ENDIAN);

        double x = in.getDouble();

        double y = in.getDouble();

        double x2 = in.getDouble();

        if (x2 - x == 0) {

            x2 += 0.2;

            x -= 0.1;

        }

        double y2 = in.getDouble();

        if (y2 - y == 0) {

            y2 += 0.2;

            y -= 0.1;

        }

        Envelope tempEnvelope

                = gManager.createEnvelope(x, y, x2, y2, SUBTYPES.GEOM2D);

        return tempEnvelope;

    }

    /**

     * Gets the geometry bbox with the index provided. Set to synchronized to

     * prevent concurrent threads issue (?)

     *

     * @param featureIndex

     * @return

     * @throws ReadException

     * @throws CreateEnvelopeException

     * @throws CreateGeometryException

     */

    public synchronized Envelope getBoundingBox(long featureIndex)

        throws ReadException, CreateEnvelopeException, CreateGeometryException {

        Point p;

        Envelope BoundingBox = null;

        try {

            bb.position(getPositionForRecord(featureIndex));

        } catch (Exception e) {

            throw new ReadException("getBondingBox (" + featureIndex + ")", e);

            // logger.error(" Shapefile is corrupted. Drawing aborted. ="+e+

            // "  "+"index = "+index);

        }

        bb.order(ByteOrder.LITTLE_ENDIAN);

        int tipoShape = bb.getInt();

        // AZABALA: si tipoShape viene con valores erroneos deja de funcionar

        // el metodo getShape(i)

        // if (tipoShape != SHP.NULL) {

        // type = tipoShape;

        // }

        // retrieve that shape.

        // tempRecord.setShape(readShape(tempShapeType, tempContentLength, in));

        switch (tipoShape) {

        case (SHP.POINT2D):

        case (SHP.POINT3D):

            p = readPoint(bb);

                BoundingBox

                        = gManager.createEnvelope(p.getX() - 0.1, p.getY() - 0.1,

                    p.getX() + 0.2, p.getY() + 0.2, SUBTYPES.GEOM2D);

            // new Rectangle2D.Double(p.getX() - 0.1,

            // p.getY() - 0.1, 0.2, 0.2);

            break;

        case (SHP.POLYLINE2D):

        case (SHP.POLYLINEM):

        case (SHP.POLYGON2D):

        case (SHP.POLYGONM):

        case (SHP.MULTIPOINT2D):

        case (SHP.MULTIPOINTM):

        case (SHP.POLYLINE3D):

        case (SHP.POLYGON3D):

        case (SHP.MULTIPOINT3D):

            // BoundingBox

            BoundingBox = readRectangle(bb);

            break;

        }

        return BoundingBox;

    }

    /**

     * @return

     */

    public String getSRSParameters() {

        return this.srsParameters;

    }

    private void initSupportedGeometryTypes() throws ReadException {

        switch (this.getGeometryType()) {

        case Geometry.TYPES.POINT:

                supportedGeometryTypes

                        = new int[]{Geometry.TYPES.POINT, Geometry.TYPES.NULL};

            break;

        case Geometry.TYPES.MULTIPOINT:

                supportedGeometryTypes

                        = new int[]{Geometry.TYPES.MULTIPOINT, Geometry.TYPES.NULL};

            break;

        case Geometry.TYPES.MULTICURVE:

                supportedGeometryTypes

                        = new int[]{Geometry.TYPES.CURVE, Geometry.TYPES.ELLIPSE,

                    Geometry.TYPES.ARC, Geometry.TYPES.CIRCLE,

                    Geometry.TYPES.SURFACE, Geometry.TYPES.NULL,

                            Geometry.TYPES.MULTICURVE};

            break;

        case Geometry.TYPES.MULTISURFACE:

                supportedGeometryTypes

                        = new int[]{Geometry.TYPES.ELLIPSE, Geometry.TYPES.CIRCLE,

                    Geometry.TYPES.SURFACE, Geometry.TYPES.NULL,

                            Geometry.TYPES.MULTISURFACE};

            break;

        default:

                supportedGeometryTypes = new int[]{};

        }

    }

    public boolean canWriteGeometry(int gvSIGgeometryType) {

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

            if (gvSIGgeometryType == supportedGeometryTypes[i]) {

                return true;

            }

        }

        return false;

    }

}