Application: gvSIG desktop

/*

 * WKBParser.java

 * Based in 

 * PostGIS extension for PostgreSQL JDBC driver - Binary Parser

 * 

 * NOTA: Es posible que lo mejor sea crear un PostGisGeometry que implemente

 * la interfaz IGeometry, y as? nos sirve de base para tener IGeometries

 * que encapsulan otras posibles geometr?as. Por ejemplo, un JTSGeometry.

 * De esta forma, un driver no necesitar?a reescribirse.

 * 

 * (C) 2005 Markus Schaber, schabios@logi-track.com

 * 

 * This library is free software; you can redistribute it and/or modify it under

 * the terms of the GNU Lesser General Public License as published by the Free

 * Software Foundation, either version 2.1 of the License.

 * 

 * This library 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 Lesser General Public License for more

 * details.

 * 

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

 * along with this library; if not, write to the Free Software Foundation, Inc.,

 * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA or visit the web at

 * http://www.gnu.org.

 * 

 * $Id: WKBParser.java 1826 2005-04-21 09:41:04Z  $

 */

package com.iver.cit.gvsig.fmap.drivers;

import org.postgis.Geometry;

import org.postgis.GeometryCollection;

import org.postgis.LineString;

import org.postgis.LinearRing;

import org.postgis.MultiLineString;

import org.postgis.MultiPoint;

import org.postgis.MultiPolygon;

import org.postgis.Point;

import org.postgis.Polygon;

import org.postgis.binary.ByteGetter;

import org.postgis.binary.ValueGetter;

import org.postgis.binary.ByteGetter.BinaryByteGetter;

import org.postgis.binary.ByteGetter.StringByteGetter;

import com.iver.cit.gvsig.fmap.core.FGeometryCollection;

import com.iver.cit.gvsig.fmap.core.FMultiPoint2D;

import com.iver.cit.gvsig.fmap.core.FPoint2D;

import com.iver.cit.gvsig.fmap.core.FPoint3D;

import com.iver.cit.gvsig.fmap.core.FPolygon2D;

import com.iver.cit.gvsig.fmap.core.FPolyline2D;

import com.iver.cit.gvsig.fmap.core.GeneralPathX;

import com.iver.cit.gvsig.fmap.core.IGeometry;

import com.iver.cit.gvsig.fmap.core.ShapeFactory;

/**

 * Parse binary representation of geometries. Currently, only text rep (hexed)

 * implementation is tested.

 * 

 * It should be easy to add char[] and CharSequence ByteGetter instances,

 * although the latter one is not compatible with older jdks.

 * 

 * I did not implement real unsigned 32-bit integers or emulate them with long,

 * as both java Arrays and Strings currently can have only 2^31-1 elements

 * (bytes), so we cannot even get or build Geometries with more than approx.

 * 2^28 coordinates (8 bytes each).

 * 

 * @author markus.schaber@logi-track.com

 *  

 */

public class WKBParser {

    private boolean gHaveM, gHaveZ, gHaveS; // M, Z y SRID

    /**

     * Get the appropriate ValueGetter for my endianness

     * 

     * @param bytes The appropriate Byte Getter

     * 

     * @return the ValueGetter

     */    

    public static ValueGetter valueGetterForEndian(ByteGetter bytes) {

        if (bytes.get(0) == ValueGetter.XDR.NUMBER) { // XDR

            return new ValueGetter.XDR(bytes);

        } else if (bytes.get(0) == ValueGetter.NDR.NUMBER) {

            return new ValueGetter.NDR(bytes);

        } else {

            throw new IllegalArgumentException("Unknown Endian type:" + bytes.get(0));

        }

    }

    /**

     * Parse a hex encoded geometry

     * 

     * Is synchronized to protect offset counter. (Unfortunately, Java does not

     * have neither call by reference nor multiple return values.)

     */

    public synchronized IGeometry parse(String value) {

        StringByteGetter bytes = new ByteGetter.StringByteGetter(value);

        return parseGeometry(valueGetterForEndian(bytes));

    }

    /**

     * Parse a binary encoded geometry.

     * 

     * Is synchronized to protect offset counter. (Unfortunately, Java does not

     * have neither call by reference nor multiple return values.)

     */

    public synchronized IGeometry parse(byte[] value) {

        BinaryByteGetter bytes = new ByteGetter.BinaryByteGetter(value);

        return parseGeometry(valueGetterForEndian(bytes));

    }

    protected void parseTypeAndSRID(ValueGetter data)

    {

        byte endian = data.getByte(); //skip and test endian flag

        if (endian != data.endian) {

            throw new IllegalArgumentException("Endian inconsistency!");

        }

        int typeword = data.getInt();

        int realtype = typeword & 0x1FFFFFFF; //cut off high flag bits

        gHaveZ = (typeword & 0x80000000) != 0;

        gHaveM = (typeword & 0x40000000) != 0;

        gHaveS = (typeword & 0x20000000) != 0;

        int srid = -1;

        if (gHaveS) {

            srid = data.getInt();

        }

    }

    /** Parse a geometry starting at offset. */

    protected IGeometry parseGeometry(ValueGetter data) {

        byte endian = data.getByte(); //skip and test endian flag

        if (endian != data.endian) {

            throw new IllegalArgumentException("Endian inconsistency!");

        }

        int typeword = data.getInt();

        int realtype = typeword & 0x1FFFFFFF; //cut off high flag bits

        boolean haveZ = (typeword & 0x80000000) != 0;

        boolean haveM = (typeword & 0x40000000) != 0;

        boolean haveS = (typeword & 0x20000000) != 0;

        int srid = -1;

        if (haveS) {

            srid = data.getInt();

        }

        IGeometry result1;

        switch (realtype) {

        case Geometry.POINT :

            result1 = ShapeFactory.createPoint2D(parsePoint(data, haveZ, haveM));

            break;

        case Geometry.LINESTRING :

            result1 = ShapeFactory.createGeometry(parseLineString(data, haveZ, haveM));

            break;

        case Geometry.POLYGON :

            result1 = ShapeFactory.createGeometry(parsePolygon(data, haveZ, haveM));

            break;

        case Geometry.MULTIPOINT :

            result1 = parseMultiPoint(data);

            break;

        case Geometry.MULTILINESTRING :

            result1 = ShapeFactory.createGeometry(parseMultiLineString(data));

            break;

        case Geometry.MULTIPOLYGON :

            result1 = ShapeFactory.createGeometry(parseMultiPolygon(data));

            break;

        case Geometry.GEOMETRYCOLLECTION :

            result1 = parseCollection(data);

            break;

        default :

            throw new IllegalArgumentException("Unknown Geometry Type!");

        }

        /*Geometry result = result1;

        if (haveS) {

            result.setSrid(srid);

        } */

        return result1;

    }

    private FPoint2D parsePoint(ValueGetter data, boolean haveZ, boolean haveM) {

        double X = data.getDouble();

        double Y = data.getDouble();

        FPoint2D result;

        if (haveZ) {

            double Z = data.getDouble();

            result = new FPoint3D(X, Y, Z);

        } else {

            result = new FPoint2D(X, Y);

        }

        if (haveM) {

            System.err.println("M no soportado. (WKBParser de gvSIG, dentro de parsePoint)");

            double m = data.getDouble();

            // result.setM(m);

        }

        return result;

    }

    /** Parse an Array of "full" Geometries */

    private void parseGeometryArray(ValueGetter data, IGeometry[] container) {

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

            container[i] = parseGeometry(data);

        }

    }

    /**

     * Parse an Array of "slim" Points (without endianness and type, part of

     * LinearRing and Linestring, but not MultiPoint!

     * 

     * @param haveZ

     * @param haveM

     */

    private FPoint2D[] parsePointArray(ValueGetter data, boolean haveZ, boolean haveM) {

        int count = data.getInt();

        FPoint2D[] result = new FPoint2D[count];

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

            result[i] = parsePoint(data, haveZ, haveM);

        }

        return result;

    }

    private FMultiPoint2D parseMultiPoint(ValueGetter data) {

        FPoint2D[] points = new FPoint2D[data.getInt()];

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

        {

            parseTypeAndSRID(data);

            parsePoint(data, gHaveZ, gHaveM);

        }

        return new FMultiPoint2D(points);

    }

    private FPolyline2D parseLineString(ValueGetter data, boolean haveZ, boolean haveM) {

        FPoint2D[] points = parsePointArray(data, haveZ, haveM);

        GeneralPathX gp = new GeneralPathX();

        gp.moveTo(points[0].getX(), points[0].getY());

        for (int i = 1; i< points.length; i++)

        {

            gp.lineTo(points[i].getX(), points[i].getY());

        }

        return new FPolyline2D(gp);

    }

    private FPolygon2D parseLinearRing(ValueGetter data, boolean haveZ, boolean haveM) {

        FPoint2D[] points = parsePointArray(data, haveZ, haveM);

        GeneralPathX gp = new GeneralPathX();

        gp.moveTo(points[0].getX(), points[0].getY());

        for (int i = 1; i< points.length; i++)

        {

            gp.lineTo(points[i].getX(), points[i].getY());

        }

        return new FPolygon2D(gp);

    }

    private FPolygon2D parsePolygon(ValueGetter data, boolean haveZ, boolean haveM) {

        int count = data.getInt();

        FPolygon2D[] rings = new FPolygon2D[count];

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

            rings[i] = parseLinearRing(data, haveZ, haveM);

        }

        return rings[0]; //new FPolygon2D(rings[0]);

    }

    private FPolyline2D parseMultiLineString(ValueGetter data) {

        int count = data.getInt();

        FPolyline2D[] strings = new FPolyline2D[count];   

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

        {

            parseTypeAndSRID(data);

            strings[i] = parseLineString(data, gHaveZ, gHaveM);

        }

        // parseGeometryArray(data, strings);

        return strings[0]; //new MultiLineString(strings);

    }

    private FPolygon2D parseMultiPolygon(ValueGetter data) {

        int count = data.getInt();

        FPolygon2D[] polys = new FPolygon2D[count];

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

        {

            parseTypeAndSRID(data);

            polys[i] = parsePolygon(data, gHaveZ, gHaveM);

        }

        // parseGeometryArray(data, polys);

        return polys[0]; //new MultiPolygon(polys);

    }

    private FGeometryCollection parseCollection(ValueGetter data) {

        int count = data.getInt();

        IGeometry[] geoms = new IGeometry[count];

        parseGeometryArray(data, geoms);

        return new FGeometryCollection(geoms);

    }

}