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.geom.jts.operation.towkb;

import java.io.ByteArrayOutputStream;

import java.io.DataOutputStream;

import java.io.IOException;

import org.apache.commons.io.EndianUtils;

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

import org.gvsig.fmap.geom.aggregate.Aggregate;

import org.gvsig.fmap.geom.aggregate.MultiLine;

import org.gvsig.fmap.geom.aggregate.MultiPoint;

import org.gvsig.fmap.geom.aggregate.MultiPolygon;

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

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

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

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

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

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

public class OGCWKBEncoder {

    public interface wkbGeometryType {

        public final static int wkbPoint = 1;

        public final static int wkbLineString = 2;

        public final static int wkbPolygon = 3;

        public final static int wkbTriangle = 17;

        public final static int wkbMultiPoint = 4;

        public final static int wkbMultiLineString = 5;

        public final static int wkbMultiPolygon = 6;

        public final static int wkbGeometryCollection = 7;

        public final static int wkbPolyhedralSurface = 15;

        public final static int wkbTIN = 16;

        public final static int wkbPointZ = 1001;

        public final static int wkbLineStringZ = 1002;

        public final static int wkbPolygonZ = 1003;

        public final static int wkbTrianglez = 1017;

        public final static int wkbMultiPointZ = 1004;

        public final static int wkbMultiLineStringZ = 1005;

        public final static int wkbMultiPolygonZ = 1006;

        public final static int wkbGeometryCollectionZ = 1007;

        public final static int wkbPolyhedralSurfaceZ = 1015;

        public final static int wkbTINZ = 1016;

        public final static int wkbPointM = 2001;

        public final static int wkbLineStringM = 2002;

        public final static int wkbPolygonM = 2003;

        public final static int wkbTriangleM = 2017;

        public final static int wkbMultiPointM = 2004;

        public final static int wkbMultiLineStringM = 2005;

        public final static int wkbMultiPolygonM = 2006;

        public final static int wkbGeometryCollectionM = 2007;

        public final static int wkbPolyhedralSurfaceM = 2015;

        public final static int wkbTINM = 2016;

        public final static int wkbPointZM = 3001;

        public final static int wkbLineStringZM = 3002;

        public final static int wkbPolygonZM = 3003;

        public final static int wkbTriangleZM = 3017;

        public final static int wkbMultiPointZM = 3004;

        public final static int wkbMultiLineStringZM = 3005;

        public final static int wkbMultiPolygonZM = 3006;

        public final static int wkbGeometryCollectionZM = 3007;

        public final static int wkbPolyhedralSurfaceZM = 3015;

        public final static int wkbTinZM = 3016;

        public final static int wkb_baseToZ = wkbPointZ - wkbPoint;

        public final static int wkb_baseToM = wkbPointM - wkbPoint;

        public final static int wkb_baseToZM = wkbPointZM - wkbPoint;

    }

    public interface wkbByteOrder {

        public final static byte wkbXDR = 0;                // Big Endian

        public final static byte wkbNDR = 1;                // Little Endian

    }

    private int byteOrder;

    public OGCWKBEncoder() {

        this(wkbByteOrder.wkbXDR);

    }

    public OGCWKBEncoder(int byteOrder) {

        this.byteOrder = byteOrder;

    }

    public byte[] encode(Geometry geometry)

            throws GeometryTypeNotSupportedException,

            WKBEncodingException,

            IOException {

        ByteArrayOutputStream stream;

        if (geometry.getType() == TYPES.POINT) {

            stream = new ByteArrayOutputStream(50);

        } else {

            stream = new ByteArrayOutputStream(512);

        }

        encode(geometry, stream);

        return stream.toByteArray();

    }

    public void encode(Geometry geometry, ByteArrayOutputStream stream)

            throws GeometryTypeNotSupportedException, WKBEncodingException,

            IOException {

        encode(geometry, new DataOutputStream(stream));

    }

    public void encode(Geometry geometry, DataOutputStream stream)

            throws GeometryTypeNotSupportedException,

            WKBEncodingException,

            IOException {

        if (geometry.getGeometryType().isTypeOf(TYPES.POINT)) {

            encodePoint(geometry, stream);

        } else if (geometry.getGeometryType().isTypeOf(TYPES.LINE)) {

            encodeLineString((Line)geometry, stream);

        } else if (geometry.getGeometryType().isTypeOf(TYPES.CURVE)) {

            try {

                MultiLine lines = geometry.toLines();

                if(lines.getPrimitivesNumber() == 1){

                    encodeLineString((Line) lines.getPrimitiveAt(0), stream);

                } else {

                    encodeMultiLineString(lines, stream);

                }

            } catch (GeometryException ex) {

                throw new WKBEncodingException(ex);

            }

        } else if (geometry.getGeometryType().isTypeOf(TYPES.POLYGON)) {

            encodePolygon((Polygon) geometry, stream);

        } else if (geometry.getGeometryType().isTypeOf(TYPES.SURFACE)) {

            try {

                MultiPolygon pols = geometry.toPolygons();

                if(pols.getPrimitivesNumber() == 1){

                    encodePolygon((Polygon) pols.getPrimitiveAt(0), stream);

                } else {

                    encodeMultiPolygon(pols, stream);

                }

            } catch (GeometryException ex) {

                throw new WKBEncodingException(ex);

            }

        } else if (geometry.getGeometryType().isTypeOf(TYPES.AGGREGATE)) {

            switch (geometry.getType()) {

                case TYPES.MULTIPOINT:

                    encodeMultiPoint(geometry, stream);

                    break;

                case TYPES.MULTICURVE:

                    try {

                        encodeMultiLineString(geometry.toLines(), stream);

                    } catch (GeometryException ex) {

                        throw new WKBEncodingException(ex);

                    }

                    break;

                case TYPES.MULTILINE:

                    encodeMultiLineString((MultiLine) geometry, stream);

                    break;

                case TYPES.MULTISURFACE:

                    try {

                        encodeMultiPolygon(geometry.toPolygons(), stream);

                    } catch (GeometryException ex) {

                        throw new WKBEncodingException(ex);

                    }

                    break;

                case TYPES.MULTIPOLYGON:

                    encodeMultiPolygon((MultiPolygon) geometry, stream);

                    break;

                case TYPES.AGGREGATE:

                    encodeCollection(geometry, stream);

                    break;

            }

        } else {

            throw new GeometryTypeNotSupportedException(geometry.getType(),

                    geometry.getGeometryType().getSubType());

        }

//

//            // FIXME geom.subtype != SUBTYPES.GEOM2D NOT SUPPORTED !!!!

//            if (geometry.getGeometryType().getSubType() != SUBTYPES.GEOM2D) {

//                throw new GeometryTypeNotSupportedException(geometry.getType(),

//                        geometry.getGeometryType().getSubType());

//            }

    }

    private void encodeCollection(Geometry geometry, DataOutputStream stream)

            throws GeometryTypeNotSupportedException,

            WKBEncodingException,

            IOException {

        GeometryType geometryType = geometry.getGeometryType();

        encodeWKBGeomHead(wkbGeometryType.wkbGeometryCollection, geometryType,

                stream);

        Aggregate collection = (Aggregate) geometry;

        int nGeometries = collection.getPrimitivesNumber();

        encodeInteger(nGeometries, stream);

        for (int i = 0; i < nGeometries; i++) {

            encode(collection.getPrimitiveAt(i), stream);

        }

    }

    private void encodeMultiPolygon(MultiPolygon geometry, DataOutputStream stream)

            throws GeometryTypeNotSupportedException,

            WKBPolygonNotClosedException, IOException {

        GeometryType geometryType = geometry.getGeometryType();

        encodeWKBGeomHead(wkbGeometryType.wkbMultiPolygon, geometryType, stream);

        int nGeometries = geometry.getPrimitivesNumber();

        encodeInteger(nGeometries, stream);

        for (int i = 0; i < nGeometries; i++) {

            encodePolygon((Polygon) geometry.getPrimitiveAt(i), stream);

        }

    }

    private void encodePolygon(Polygon geometry, DataOutputStream stream)

            throws GeometryTypeNotSupportedException,

            WKBPolygonNotClosedException, IOException {

        GeometryType geometryType = geometry.getGeometryType();

        encodeWKBGeomHead(wkbGeometryType.wkbPolygon, geometryType, stream);

        encodeInteger(1 + geometry.getNumInteriorRings(), stream);

        encodeLinearRing(geometry, stream);

        for (int i = 0; i < geometry.getNumInteriorRings(); i++) {

            Ring ring = geometry.getInteriorRing(i);

            encodeLinearRing(ring, stream);

        }

    }

    private void encodeLinearRing(Ring geom, DataOutputStream stream)

            throws IOException {

        encodeInteger(geom.getNumVertices(), stream);

        for (Point point : geom) {

            encodeCoordinates(point.getCoordinates(), stream);

        }

    }

    private void encodeMultiLineString(MultiLine geometry, DataOutputStream stream)

            throws GeometryTypeNotSupportedException,

            WKBPolygonNotClosedException, IOException {

        GeometryType geometryType = geometry.getGeometryType();

        encodeWKBGeomHead(wkbGeometryType.wkbMultiLineString, geometryType, stream);

        int nGeometries = geometry.getPrimitivesNumber();

        encodeInteger(nGeometries, stream);

        for (int i = 0; i < nGeometries; i++) {

            encodeLineString((Line) geometry.getPrimitiveAt(i), stream);

        }

    }

        private void encodeLineString(Line geometry, DataOutputStream stream)

            throws GeometryTypeNotSupportedException,

            WKBPolygonNotClosedException, IOException {

        GeometryType geometryType = geometry.getGeometryType();

        encodeWKBGeomHead(wkbGeometryType.wkbLineString, geometryType, stream);

        int nVertices = geometry.getNumVertices();

        encodeInteger(nVertices, stream);

        for (Point point : geometry) {

            encodeCoordinates(point.getCoordinates(), stream);

        }

    }

    private void encodeDouble(double data, DataOutputStream stream)

            throws IOException {

        if (this.byteOrder == wkbByteOrder.wkbXDR) {

            stream.writeDouble(data);

        } else {

            EndianUtils.writeSwappedDouble(stream, data);

        }

    }

    private void encodeInteger(int data, DataOutputStream stream)

            throws IOException {

        if (this.byteOrder == wkbByteOrder.wkbXDR) {

            stream.writeInt(data);

        } else {

            EndianUtils.writeSwappedInteger(stream, data);

        }

    }

    private void encodeCoordinates(double[] coordinates, DataOutputStream stream)

            throws IOException {

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

            encodeDouble(coordinates[i], stream);

        }

    }

    private void encodeWKBGeomHead(int wkbBaseType, GeometryType geometryType,

            DataOutputStream stream) throws GeometryTypeNotSupportedException,

            IOException {

        stream.writeByte(this.byteOrder);

        int finalType = wkbBaseType % wkbGeometryType.wkb_baseToZ;

        switch (geometryType.getSubType()) {

            case SUBTYPES.GEOM2D:

                break;

            case SUBTYPES.GEOM2DM:

                finalType = finalType + wkbGeometryType.wkb_baseToM;

                break;

            case SUBTYPES.GEOM3D:

                finalType = finalType + wkbGeometryType.wkb_baseToZ;

                break;

            case SUBTYPES.GEOM3DM:

                finalType = finalType + wkbGeometryType.wkb_baseToZM;

                break;

            default:

                throw new GeometryTypeNotSupportedException(geometryType.getType(),

                        geometryType.getSubType());

        }

        encodeInteger(finalType, stream);

    }

    private void encodePoint(Geometry geometry, DataOutputStream stream)

            throws GeometryTypeNotSupportedException, IOException {

        GeometryType geometryType = geometry.getGeometryType();

        encodeWKBGeomHead(wkbGeometryType.wkbPoint, geometryType,

                stream);

        Point point = (Point) geometry;

        encodeCoordinates(point.getCoordinates(), stream);

    }

    private void encodeMultiPoint(Geometry geometry, DataOutputStream stream)

            throws GeometryTypeNotSupportedException, IOException {

        GeometryType geometryType = geometry.getGeometryType();

        encodeWKBGeomHead(wkbGeometryType.wkbMultiPoint, geometryType, stream);

        MultiPoint points = (MultiPoint) geometry;

        int nGeometries = points.getPrimitivesNumber();

        encodeInteger(nGeometries, stream);

        for (int i = 0; i < nGeometries; i++) {

            encodePoint(points.getPrimitiveAt(i), stream);

        }

    }

}