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;

import java.awt.geom.PathIterator;

import java.io.IOException;

import java.io.Reader;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.Iterator;

import java.util.List;

import java.util.Map;

import org.apache.commons.codec.binary.Hex;

import org.apache.commons.io.IOUtils;

import org.apache.commons.lang3.StringUtils;

import org.cresques.cts.IProjection;

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

import org.gvsig.fmap.geom.GeometryException;

import org.gvsig.fmap.geom.GeometryLocator;

import org.gvsig.fmap.geom.GeometryManager;

import org.gvsig.fmap.geom.GeometryUtils;

import org.gvsig.fmap.geom.InformationbuilderWithGeometrySupport;

import org.gvsig.fmap.geom.SpatialIndex;

import org.gvsig.fmap.geom.SpatialIndexFactory;

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

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.aggregate.MultiPrimitive;

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

import org.gvsig.fmap.geom.exception.CreateEnvelopeException;

import org.gvsig.fmap.geom.exception.CreateGeometryException;

import org.gvsig.fmap.geom.jts.coerce.DefaultGeometryCoercionContext;

import org.gvsig.fmap.geom.jts.gputils.DefaultGeneralPathX;

import org.gvsig.fmap.geom.jts.primitive.DefaultNullGeometry;

import org.gvsig.fmap.geom.jts.primitive.Envelope2D;

import org.gvsig.fmap.geom.jts.primitive.Envelope3D;

import org.gvsig.fmap.geom.jts.spatialindex.SpatialIndexFactoryJTSQuadtree;

import org.gvsig.fmap.geom.jts.util.GMLUtils;

import org.gvsig.fmap.geom.jts.util.JTSUtils;

import org.gvsig.fmap.geom.operation.GeometryOperation;

import org.gvsig.fmap.geom.operation.GeometryOperationContext;

import org.gvsig.fmap.geom.operation.GeometryOperationException;

import org.gvsig.fmap.geom.operation.GeometryOperationNotSupportedException;

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

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

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

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

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

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

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

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

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

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.dynobject.DynObject;

import org.gvsig.tools.library.impl.DefaultLibrariesInitializer;

import org.gvsig.tools.service.Service;

import org.gvsig.tools.service.ServiceException;

import org.gvsig.tools.service.spi.ServiceFactory;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 * Default implementation for the {@link GeometryManager}. When the

 * application starts, this class is registered in the {@link GeometryLocator}

 * using the {@link DefaultGeometryLibrary}.

 *

 * @author <a href="mailto:jpiera@gvsig.org">Jorge Piera</a>

 */

@SuppressWarnings("UseSpecificCatch")

public class DefaultGeometryManager implements GeometryManager {

    private static final Logger LOGGER = LoggerFactory.getLogger(GeometryManager.class);

    /**

     * Offset for GeometryType -1 value (UNKNOWN)

     */

    private final int GEOMETRY_TYPE_OFFSET = 1;

    private double flatness = 0.8;

    private final Map spatialIndexFactories = new HashMap();

    /**

     * This list holds the unique name of all registered geometry operations.

     * The index in which they are stored is also the operation code used to

     * invoke each one of them

     */

    private final List geometryOperations = new ArrayList();

    /**

     * Common operations are registered here. Type specific operations are

     * registered in the corresponding GeometryType instance

     */

    // private List commonOperations = new ArrayList();

    /**

     * This map holds the instances of all registered GeometryType. The key is

     * the name of the specific Geometry subclass.

     * In other words, the string "org.gvsig.fmap.geom.primitive.Point2D" is the

     * hash key to obtain an instance of GeometryType holding the

     * operations associated to the class org.gvsig.fmap.geom.primitive.Point2D.

     */

    private final Map geometryTypeName = new HashMap();

    /**

     * Matrix of geometry types by type (row) and subtype (column). This matrix

     * will contain null values in the cells where a GeometryType hasn't been

     * registered.

     */

    private GeometryType[][] geometryTypes;

    // Initially create a matrix of 27 x 6, which are the current default

    // types and subtypes. If another type or subtype is registered, the

    // matrix will grow as needed

    private static final int DEFAULT_TYPES_SIZE = 27; // [-1, 25]

    private static final int DEFAULT_SUBTYPES_SIZE = 6;

    public DefaultGeometryManager() throws GeometryException {

        this(DEFAULT_TYPES_SIZE, DEFAULT_SUBTYPES_SIZE);

    }

    public DefaultGeometryManager(int initialTypesSize, int initialSubtypesSize) throws GeometryException {

        geometryTypes = new GeometryType[initialTypesSize][initialSubtypesSize];

    }

    @Override

    public int registerGeometryOperation(String geomOpName, GeometryOperation geomOp, GeometryType geomType) {

        if (geomOp == null) {

            throw new IllegalArgumentException("geomOp cannot be null.");

        }

        if (geomType == null) {

            throw new IllegalArgumentException("geomType cannot be null.");

        }

        int index = getGeometryOperationCode(geomOpName);

        geomType.setGeometryOperation(index, geomOp);

        return index;

    }

    @Override

    public int registerGeometryOperation(String geomOpName, GeometryOperation geomOp) {

        if (geomOpName == null) {

            throw new IllegalArgumentException("geomOpName cannot be null.");

        }

        if (geomOp == null) {

            throw new IllegalArgumentException("geomOp cannot be null.");

        }

        int index = getGeometryOperationCode(geomOpName);

        Iterator it = geometryTypeName.values().iterator();

        while (it.hasNext()) {

            GeometryType geometryType = (GeometryType) it.next();

            registerGeometryOperation(geomOpName, geomOp, geometryType);

        }

        return index;

    }

    @SuppressWarnings("override")

    public int registerGeometryOperation(String geomOpName, GeometryOperation geomOp, int type, int subType)

        throws GeometryTypeNotSupportedException, GeometryTypeNotValidException {

        GeometryType geometryType = getGeometryType(type, subType);

        return registerGeometryOperation(geomOpName, geomOp, geometryType);

    }

    @Override

    public int registerGeometryOperation(String geomOpName, GeometryOperation geomOp, int type) {

        int code = -1;

        Iterator it = geometryTypeName.values().iterator();

        while (it.hasNext()) {

            GeometryType geometryType = (GeometryType) it.next();

            if ((type == geometryType.getType())) {

                code = registerGeometryOperation(geomOpName, geomOp, geometryType);

            }

        }

        return code;

    }

    @Override

    public int registerGeometryOperationBySubtype(String geomOpName, GeometryOperation geomOp, int subType) {

        int code = -1;

        Iterator it = geometryTypeName.values().iterator();

        while (it.hasNext()) {

            GeometryType geometryType = (GeometryType) it.next();

            if ((subType == geometryType.getSubType())) {

                code = registerGeometryOperation(geomOpName, geomOp, geometryType);

            }

        }

        return code;

    }

    @Override

    public int registerGeometryOperationBySuperType(String geomOpName, GeometryOperation geomOp, int superType) {

        int code = -1;

        Iterator it = geometryTypeName.values().iterator();

        while (it.hasNext()) {

            GeometryType geometryType = (GeometryType) it.next();

            if (geometryType.isTypeOf(superType)) {

                code = registerGeometryOperation(geomOpName, geomOp, geometryType);

            }

        }

        return code;

    }

    @Override

    public int registerGeometryOperationBySuperSubType(String geomOpName, GeometryOperation geomOp, int superSubType) {

        int code = -1;

        Iterator it = geometryTypeName.values().iterator();

        while (it.hasNext()) {

            GeometryType geometryType = (GeometryType) it.next();

            if (geometryType.isSubTypeOf(superSubType)) {

                code = registerGeometryOperation(geomOpName, geomOp, geometryType);

            }

        }

        return code;

    }

    @Override

    public GeometryType registerGeometryType(Class geomClass, String name, int type, int subType) {

        return registerGeometryType(geomClass, name, type, subType, new int[0], new int[0]);

    }

    @Override

    public GeometryType registerGeometryType(Class geomClass, String name, int type, int subType, int superType,

        int superSubType) {

        return registerGeometryType(geomClass, name, type, subType, new int[] { superType }, new int[] { superSubType });

    }

    @Override

    public GeometryType registerGeometryType(Class geomClass, String name, int type, int subType, int superType) {

        return registerGeometryType(geomClass, name, type, subType, new int[] { superType }, new int[0]);

    }

    @Override

    public GeometryType registerGeometryType(Class geomClass, String name, int type, int subType, int[] superTypes) {

        return registerGeometryType(geomClass, name, type, subType, superTypes, new int[0]);

    }

    /**

     * Registers a Geometry implementation class with a predefined geometry type

     * and returns the

     * associated GeometryType instance. Available predefined types are defined

     * in {@link Geometry.TYPES} If the class is already registered then this

     * method throws an IllegalArgumentException.<br>

     *

     * How to register a geometry class with a predefined type:

     *

     * <pre>

     *

     * public class Point2D implements Point {

     *   private static final GeometryType geomType = GeometryManager.getInstance()

     *    .registerBasicGeometryType(Point2D.class, "Point2D", Geometry.TYPES.POINT);

     *

     * ...

     *   public int getType() {

     *      return geomType.getType();

     *   }

     * }

     * </pre>

     *

     * @param geomClass

     *            Geometry subclass. It must not be null and must implement

     *            Geometry, otherwise an exception

     *            is raised.

     * @param name

     *            Symbolic name for the geometry type, it can be null. If it is

     *            null then the symbolic name

     *            will be the simple class name.

     * @param type

     *            Type of geometry. Must be a value defined in

     *            {@link Geometry.TYPES}

     * @param subType

     *            SubType of geometry. Must be a value defined in

     *            {@link Geometry.SUBTYPES}

     * @return Instance of GeometryType associated to the Geometry

     *         implementation class

     *         geomClass

     * @throws IllegalArgumentException

     *             If geomClass is null or does not implement Geometry

     */

    @Override

    public GeometryType registerGeometryType(Class geomClass, String name, int type, int subType, int[] superTypes,

        int superSubTypes[]) {

        if (geomClass == null) {

            throw new IllegalArgumentException("geomClass cannot be null.");

        }

        if (!Geometry.class.isAssignableFrom(geomClass)) {

            throw new IllegalArgumentException(geomClass.getName() + " must implement the Geometry interface");

        }

        int offsettedType = type + GEOMETRY_TYPE_OFFSET;

        // Check if it is registered

        GeometryType geomType = null;

        if (offsettedType >= geometryTypes.length || subType >= geometryTypes[0].length

            || (geomType = geometryTypes[offsettedType][subType]) == null) {

            geomType = new DefaultGeometryType(geomClass, name, type, subType, superTypes, superSubTypes); //Attention!

            registerGeometryType(geomType);

        }

        LOGGER.debug("Class {} registered with name {}", geomClass, geomType.getName());

        return geomType;

    }

    @Override

    public void registerGeometryType(GeometryType geometryType) {

        int offsettedType = geometryType.getType() + GEOMETRY_TYPE_OFFSET;

        if (offsettedType >= geometryTypes.length || geometryType.getSubType() >= geometryTypes[0].length) {

            // Recreate the geometry type matrix if the types

            // or subtypes don't fit

            int newTypesSize =

                offsettedType < geometryTypes.length ? geometryTypes.length : offsettedType + 1;

            int newSubTypesSize =

                geometryType.getSubType() < geometryTypes[0].length ? geometryTypes[0].length : geometryType

                    .getSubType() + 1;

            GeometryType[][] newMatrix = new GeometryType[newTypesSize][newSubTypesSize];

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

                System.arraycopy(geometryTypes[i], 0, newMatrix[i], 0, geometryTypes[i].length);

            }

            geometryTypes = newMatrix;

        }

        geometryTypes[offsettedType][geometryType.getSubType()] = geometryType;

        geometryTypeName.put(geometryType.getName(), geometryType);

    }

    @Override

    public GeometryType registerGeometryType(Class geomClass, int type, int subType) {

        return registerGeometryType(geomClass, null, type, subType);

    }

    @Override

    public GeometryType getGeometryType(int type, int subType) throws GeometryTypeNotSupportedException,

        GeometryTypeNotValidException {

        int offsettedType = type + GEOMETRY_TYPE_OFFSET;

        if (offsettedType >= geometryTypes.length || subType >= geometryTypes[0].length) {

            throw new GeometryTypeNotValidException(type, subType);

        }

        GeometryType gType = geometryTypes[offsettedType][subType];

        if (gType == null) {

            throw new GeometryTypeNotSupportedException(type, subType);

        }

        return gType;

    }

    @Override

    public Geometry create(GeometryType geomType) throws CreateGeometryException {

        return geomType.create();

    }

    @Override

    public Geometry create(String name) throws CreateGeometryException {

        if (!geometryTypeName.containsKey(name)) {

            throw new IllegalArgumentException(name + " has not been registered yet.");

        }

        return ((GeometryType) geometryTypeName.get(name)).create();

    }

    @Override

    public Geometry create(int type, int subType) throws CreateGeometryException {

        try {

            return getGeometryType(type, subType).create();

        } catch (GeometryException e) {

            throw new CreateGeometryException(type, subType, e);

        }

    }

    @Override

    public Curve createCurve(GeneralPathX generalPathX, int subType) throws CreateGeometryException {

        Curve curve = (Curve) create(TYPES.CURVE, subType);

        curve.setGeneralPath(generalPathX);

        return curve;

    }

    @Override

    public NullGeometry createNullGeometry(int subType) throws CreateGeometryException {

        NullGeometry nullGeom = (NullGeometry) create(TYPES.NULL, subType);

        return nullGeom;

    }

    @Override

    public Point createPoint(double x, double y, int subType) throws CreateGeometryException {

        Point point = (Point) create(TYPES.POINT, subType);

        point.setX(x);

        point.setY(y);

        return point;

    }

    @Override

    public Surface createSurface(GeneralPathX generalPathX, int subType) throws CreateGeometryException {

        Surface surface = (Surface) create(TYPES.SURFACE, subType);

        surface.setGeneralPath(generalPathX);

        return surface;

    }

    @Override

    public GeometryOperation getGeometryOperation(int opCode, int type, int subType)

        throws GeometryTypeNotSupportedException, GeometryOperationNotSupportedException, GeometryTypeNotValidException {

        GeometryType geometryType = getGeometryType(type, subType);

        return geometryType.getGeometryOperation(opCode);

    }

    @Override

    public GeometryOperation getGeometryOperation(int opCode) throws GeometryOperationNotSupportedException {

        if (opCode < 0) {

            throw new GeometryOperationNotSupportedException(opCode);

        }

        GeometryType type = (GeometryType) geometryTypeName.get(DefaultNullGeometry.class.getName());

        if (type == null) {

            throw new GeometryOperationNotSupportedException(opCode);

        }

        return type.getGeometryOperation(opCode);

    }

    @Override

    public Object invokeOperation(int opCode, Geometry geom, GeometryOperationContext ctx)

        throws GeometryOperationNotSupportedException, GeometryOperationException {

        GeometryOperation geomOp = geom.getGeometryType().getGeometryOperation(opCode);

        if (geomOp != null) {

            return geomOp.invoke(geom, ctx);

        }

        throw new GeometryOperationNotSupportedException(opCode, geom.getGeometryType());

    }

    @Override

    public Object invokeOperation(String geomOpName, Geometry geom, GeometryOperationContext ctx)

        throws GeometryOperationNotSupportedException, GeometryOperationException {

        int index = geometryOperations.indexOf(geomOpName);

        if (index == -1) {

            throw new GeometryOperationNotSupportedException(-1);

        }

        return invokeOperation(index, geom, ctx);

    }

    @Override

    public Object invokeOperation(String geomOpName, GeometryOperationContext ctx)

        throws GeometryOperationNotSupportedException, GeometryOperationException {

        int index = geometryOperations.indexOf(geomOpName);

        GeometryOperation geomOp = getGeometryOperation(index);

        return geomOp.invoke(null, ctx);

    }

    @Override

    public Envelope createEnvelope(int subType) {

        // TODO: register the envelopes!!!

        switch (subType) {

        case SUBTYPES.GEOM3D:

            return new Envelope3D();

        default:

            return new Envelope2D();

        }

    }

    @Override

    public Envelope createEnvelope(double minX, double minY, double maxX, double maxY, int subType)

        throws CreateEnvelopeException {

        org.gvsig.fmap.geom.primitive.Point min = null;

        org.gvsig.fmap.geom.primitive.Point max = null;

        try {

            min = createPoint(minX, minY, subType);

            max = createPoint(maxX, maxY, subType);

        } catch (CreateGeometryException e) {

            throw new CreateEnvelopeException(subType, e);

        }

        switch (subType) {

        case SUBTYPES.GEOM2D:

        case SUBTYPES.GEOM2DM:

            // Small optimization to directly create an Envelope2D

            // return new Envelope2D(minX, minY, maxX, maxY);

            return new Envelope2D(min, max, null);

        default:

            Envelope envelope = createEnvelope(subType);

            envelope.setLowerCorner(min);

            envelope.setUpperCorner(max);

            return envelope;

        }

    }

    @Override

    public MultiCurve createMultiCurve(GeneralPathX generalPathX, int subType) throws CreateGeometryException {

        if (subType != SUBTYPES.GEOM2D) {

            // FIXME Exception

            throw new UnsupportedOperationException();

        }

        MultiCurve multiCurve = (MultiCurve) create(TYPES.MULTICURVE, subType);

        PathIterator piter = generalPathX.getPathIterator(null);

        GeneralPathX tmpPath = null;

        Curve tmpCurve;

        double[] coords = new double[6];

        double[] first = new double[6];

        int type;

        while (!piter.isDone()) {

            type = piter.currentSegment(coords);

            switch (type) {

            case PathIterator.SEG_MOVETO:

                if (tmpPath != null) {

                    tmpCurve = createCurve(tmpPath, subType);

                    multiCurve.addCurve(tmpCurve);

                }

                System.arraycopy(coords, 0, first, 0, 2);

                tmpPath = new GeneralPathX(piter.getWindingRule());

                tmpPath.moveTo(coords[0], coords[1]);

                break;

            case PathIterator.SEG_LINETO:

                if (tmpPath == null) {

                    System.arraycopy(coords, 0, first, 0, 2);

                    tmpPath = new GeneralPathX(piter.getWindingRule());

                }

                tmpPath.lineTo(coords[0], coords[1]);

                break;

            case PathIterator.SEG_QUADTO:

                if (tmpPath == null) {

                    System.arraycopy(coords, 0, first, 0, 2);

                    tmpPath = new GeneralPathX(piter.getWindingRule());

                }

                tmpPath.quadTo(coords[0], coords[1], coords[2], coords[3]);

                break;

            case PathIterator.SEG_CUBICTO:

                if (tmpPath == null) {

                    System.arraycopy(coords, 0, first, 0, 2);

                    tmpPath = new GeneralPathX(piter.getWindingRule());

                }

                tmpPath.curveTo(coords[0], coords[1], coords[2], coords[3], coords[4], coords[5]);

                break;

            case PathIterator.SEG_CLOSE:

                tmpPath.lineTo(first[0], first[1]);

                break;

            } // end switch

            piter.next();

        }

        if (tmpPath != null) {

            tmpCurve = createCurve(tmpPath, subType);

            multiCurve.addCurve(tmpCurve);

        }

        return multiCurve;

    }

    @Override

    public MultiSurface createMultiSurface(GeneralPathX generalPathX, int subType) throws CreateGeometryException {

        if (subType != SUBTYPES.GEOM2D) {

            // FIXME Exception

            throw new UnsupportedOperationException();

        }

        MultiSurface multiSurface = (MultiSurface) create(TYPES.MULTISURFACE, subType);

        PathIterator piter = generalPathX.getPathIterator(null);

        GeneralPathX tmpPath = null;

        Surface tmpSurface;

        double[] coords = new double[6];

        double[] first = new double[6];

        int type;

        while (!piter.isDone()) {

            type = piter.currentSegment(coords);

            switch (type) {

            case PathIterator.SEG_MOVETO:

                if (tmpPath != null) {

                    tmpSurface = createSurface(tmpPath, subType);

                    multiSurface.addSurface(tmpSurface);

                }

                System.arraycopy(coords, 0, first, 0, 2);

                tmpPath = new GeneralPathX(piter.getWindingRule());

                tmpPath.moveTo(coords[0], coords[1]);

            case PathIterator.SEG_LINETO:

                if (tmpPath == null) {

                    System.arraycopy(coords, 0, first, 0, 2);

                    tmpPath = new GeneralPathX(piter.getWindingRule());

                }

                tmpPath.lineTo(coords[0], coords[1]);

                break;

            case PathIterator.SEG_QUADTO:

                if (tmpPath == null) {

                    System.arraycopy(coords, 0, first, 0, 2);

                    tmpPath = new GeneralPathX(piter.getWindingRule());

                }

                tmpPath.quadTo(coords[0], coords[1], coords[2], coords[3]);

                break;

            case PathIterator.SEG_CUBICTO:

                if (tmpPath == null) {

                    System.arraycopy(coords, 0, first, 0, 2);

                    tmpPath = new GeneralPathX(piter.getWindingRule());

                }

                tmpPath.curveTo(coords[0], coords[1], coords[2], coords[3], coords[4], coords[5]);

                break;

            case PathIterator.SEG_CLOSE:

                tmpPath.lineTo(first[0], first[1]);

                break;

            } // end switch

            piter.next();

        }

        if (tmpPath != null) {

            tmpSurface = createSurface(tmpPath, subType);

            multiSurface.addSurface(tmpSurface);

        }

        return multiSurface;

    }

    @Override

    public MultiPoint createMultiPoint(GeneralPathX generalPathX, int subType) throws CreateGeometryException {

        if (subType != SUBTYPES.GEOM2D) {

            // FIXME Exception

            throw new UnsupportedOperationException();

        }

        MultiPoint multiPoint = (MultiPoint) create(TYPES.MULTIPOINT, subType);

        PathIterator piter = generalPathX.getPathIterator(null);

        Point tmpPoint;

        double[] coords = new double[6];

        int type;

        while (!piter.isDone()) {

            type = piter.currentSegment(coords);

            switch (type) {

            case PathIterator.SEG_MOVETO:

                tmpPoint = createPoint(coords[0], coords[1], subType);

                multiPoint.addPoint(tmpPoint);

            case PathIterator.SEG_LINETO:

                throw new IllegalArgumentException("The general have a SEG_LINETO.");

            case PathIterator.SEG_QUADTO:

                throw new IllegalArgumentException("The general have a SEG_QUADTO.");

            case PathIterator.SEG_CUBICTO:

                throw new IllegalArgumentException("The general have a SEG_CUBICTO.");

            case PathIterator.SEG_CLOSE:

                throw new IllegalArgumentException("The general have a SEG_CLOSE.");

            } // end switch

            piter.next();

        }

        return multiPoint;

    }

    @Override

    public int getGeometryOperationCode(String geomOpName) {

        if (geomOpName == null) {

            throw new IllegalArgumentException("geomOpName cannot be null.");

        }

        int index = geometryOperations.indexOf(geomOpName);

        if (index == -1) {

            geometryOperations.add(geomOpName);

            index = geometryOperations.indexOf(geomOpName);

        }

        return index;

    }

    @Override

    public List getGeometryOperationNames() {

        List operations = new ArrayList();

        for (int i = 0; i < operations.size(); i++) {

            operations.add(geometryOperations.get(i));

        }

        return operations;

    }

    @Override

    public double getFlatness() {

        return flatness;

    }

    @Override

    public void setFlatness(double flatness) {

        this.flatness = flatness;

    }

    @Override

    public Geometry createFrom(Object data) throws CreateGeometryException, GeometryException {

        if( data == null ) {

            throw new IllegalArgumentException("null data is not allowed");

        }

        if( data instanceof String ) {

            Geometry geom = GMLUtils.GML2Geometry((String) data);

            if( geom != null ) {

                return geom;

            }

            return this.createFrom((String)data);

        }

        if( data instanceof byte[] ) {

            return this.createFrom((byte[])data);

        }

        if( data instanceof com.vividsolutions.jts.geom.Geometry ) {

            return this.createFrom((com.vividsolutions.jts.geom.Geometry)data);

        }

        if( data instanceof Geometry ) {

            return ((Geometry)data).cloneGeometry();

        }

        throw new IllegalArgumentException("Type of data ("+data.getClass().getName()+") not supported.");

    }

    @Override

    public Geometry createFrom(String wkt, String srs) throws GeometryException {

        GeometryOperationContext context = new GeometryOperationContext();

        context.setAttribute("text", wkt);

        context.setAttribute("srs", srs);

        try {

            return (Geometry) this.invokeOperation(OPERATIONS.FROMWKT, context);

        } catch (Exception e) {

            throw new GeometryException(e);

        }

    }

    private int firstNonBlank(String s) {

        char ch;

        int i=0;

        while(i < s.length()) {

            if( !Character.isSpaceChar(ch = s.charAt(i++)) ) {

                return ch;

            }

        }

        return -1;

    } 

    private int firstNonBlank(Reader r) {

        try {

            int ch;

            int i=0;

            while( (ch=r.read())!= -1) {

                if( !Character.isSpaceChar(ch) ) {

                    return ch;

                }

            }

            return -1;

        } catch (IOException ex) {

            return -1;

        }

    } 

    @Override

    public Geometry createFrom(String geom, IProjection srs) throws GeometryException {

        try {

            if( StringUtils.isBlank(geom) ) {

                return null;

            }

            int ch = firstNonBlank(geom);

            switch(ch) {

                case '0':

                case '1':

                    if( (geom.length() % 2) == 0  ) {

                        // it starts with 0 or 1 and the length is even. Assume it is hexwkb.

                        return createFrom(Hex.decodeHex(geom.toCharArray()), srs);

                    }

                    break;

                case '{':

                    try {

                        com.vividsolutions.jts.io.geojson.GeoJsonReader reader = new com.vividsolutions.jts.io.geojson.GeoJsonReader();

                        com.vividsolutions.jts.geom.Geometry geom_jts = reader.read(geom);

                        return JTSUtils.createGeometry(srs, geom_jts);

                    } catch(Exception ex) {

                        LOGGER.debug("Can't parse as GeoJson");

                    }

                    break;

                case '<':

                    try {

                        if( StringUtils.startsWithIgnoreCase(geom.trim(),"<gml:") ) {

                            com.vividsolutions.jts.io.gml2.GMLReader reader = new com.vividsolutions.jts.io.gml2.GMLReader();

                            com.vividsolutions.jts.geom.Geometry geom_jts = reader.read(

                                    geom, 

                                    new com.vividsolutions.jts.geom.GeometryFactory()

                            );

                            return JTSUtils.createGeometry(srs, geom_jts);

                        }

                    } catch(Exception ex) {

                        LOGGER.debug("Can't parse as GML");

                    }

                    break;

            }

            GeometryOperationContext context = new GeometryOperationContext();

            context.setAttribute("text", geom);

            context.setAttribute("srs", srs);

            return (Geometry) this.invokeOperation(OPERATIONS.FROMWKT, context);

        } catch (Exception e) {

            throw new GeometryException(e);

        }

    }

    @Override

    public Geometry createFrom(Reader geom, IProjection srs) throws GeometryException {

        try {

            if( geom.markSupported() ) {

                geom.mark(10240);

                int ch = firstNonBlank(geom);

                switch(ch) {

                    case '0':

                    case '1':

                        return createFrom(Hex.decodeHex(IOUtils.toCharArray(geom)), srs);

                    case '{':

                        try {

                            com.vividsolutions.jts.io.geojson.GeoJsonReader reader = new com.vividsolutions.jts.io.geojson.GeoJsonReader();

                            com.vividsolutions.jts.geom.Geometry geom_jts = reader.read(geom);

                            return JTSUtils.createGeometry(srs, geom_jts);

                        } catch(Exception ex) {

                            LOGGER.debug("Can't parse as GeoJson");

                        }

                        break;

                    case '<':

                        try {

                            char[] buffer = new char[100];

                            IOUtils.read(geom, buffer);

                            String s = new String(buffer);

                            if( StringUtils.startsWithIgnoreCase(s,"<gml:") ) {

                                com.vividsolutions.jts.io.gml2.GMLReader reader = new com.vividsolutions.jts.io.gml2.GMLReader();

                                com.vividsolutions.jts.geom.Geometry geom_jts = reader.read(

                                        geom, 

                                        new com.vividsolutions.jts.geom.GeometryFactory()

                                );

                                return JTSUtils.createGeometry(srs, geom_jts);

                            }

                        } catch(Exception ex) {

                            LOGGER.debug("Can't parse as GML");

                        }

                        break;

                }

                geom.reset();

            }

            GeometryOperationContext context = new GeometryOperationContext();

            context.setAttribute("reader", geom);

            context.setAttribute("srs", srs);

            return (Geometry) this.invokeOperation(OPERATIONS.FROMWKT, context);

        } catch (Exception e) {

            throw new GeometryException(e);

        }

    }

    @Override

    public Geometry createFrom(String wkt) throws GeometryException {

        return this.createFrom(wkt, (IProjection)null);

    }

    public Geometry createFrom(IProjection proj, com.vividsolutions.jts.geom.Geometry geom) throws GeometryException {

        return JTSUtils.createGeometry(proj, geom);

    }

    @Override

    public Geometry createFromQuietly(String wkt) {

        try {

            return this.createFrom(wkt);

        } catch(Exception ex) {

            return null;

        }

    }

    @Override

    public Geometry createFrom(byte[] wkb) throws GeometryException {

        GeometryOperationContext context = new GeometryOperationContext();

        context.setAttribute("data", wkb);

        try {

            return (Geometry) this.invokeOperation(OPERATIONS.FROMWKB, context);

        } catch (GeometryOperationNotSupportedException e) {

            throw new GeometryException(e);

        } catch (GeometryOperationException e) {

            throw new GeometryException(e);

        }

    }

    @Override

    public Geometry createFrom(byte[] wkb, IProjection srs) throws GeometryException {

        GeometryOperationContext context = new GeometryOperationContext();

        context.setAttribute("data", wkb);

        context.setAttribute("srs", srs);

        try {

            return (Geometry) this.invokeOperation(OPERATIONS.FROMWKB, context);

        } catch (Exception e) {

            throw new GeometryException(e);

        }

    }

    @Override

    public IGeneralPathX createGeneralPath(int rule, PathIterator pathIterator) {

        if (pathIterator == null) {

            return new DefaultGeneralPathX(rule);

        }

        return new DefaultGeneralPathX(pathIterator, false, 0);

    }

    @Override

    public MultiPoint createMultiPoint(int subType) throws CreateGeometryException {

        return (MultiPoint) create(TYPES.MULTIPOINT, subType);

    }

    @Override

    public Line createLine(int subType) throws CreateGeometryException {

        return (Line) create(TYPES.CURVE, subType);

    }

    @Override

    public Curve createCurve(int subType) throws CreateGeometryException {

        return (Curve) create(TYPES.CURVE, subType);

    }

    @Override

    public MultiCurve createMultiCurve(int subType) throws CreateGeometryException {

        return (MultiCurve) create(TYPES.MULTICURVE, subType);

    }

    @Override

    public MultiLine createMultiLine(int subType) throws CreateGeometryException {

        return (MultiLine) create(TYPES.MULTILINE, subType);

    }

    @Override

    public MultiSurface createMultiSurface(int subType) throws CreateGeometryException {

        return (MultiSurface) create(TYPES.MULTISURFACE, subType);

    }

    @Override

    public MultiPolygon createMultiPolygon(int subType) throws CreateGeometryException {

        return (MultiPolygon) create(TYPES.MULTIPOLYGON, subType);

    }

    @Override

    public Polygon createPolygon(int subType) throws CreateGeometryException {

        return (Polygon) create(TYPES.SURFACE, subType);

    }

    @Override

    public Surface createSurface(int subType) throws CreateGeometryException {

        return (Surface) create(TYPES.SURFACE, subType);

    }

    @Override

    public SpatialIndex createDefaultMemorySpatialIndex() throws ServiceException {

        return this.createSpatialIndex(SpatialIndexFactoryJTSQuadtree.NAME, null);

    }

    @Override

    public SpatialIndex createSpatialIndex(String name, DynObject parameters) throws ServiceException {

        SpatialIndexFactory factory = this.getSpatialIndexFactory(name);

        if (factory == null) {

            throw new CantExistsService(name);

        }

        return (SpatialIndex) factory.create(parameters, this);

    }

    @Override

    public SpatialIndexFactory getSpatialIndexFactory(String name) {

        return (SpatialIndexFactory) this.spatialIndexFactories.get(name);

    }

    @Override

    public void addServiceFactory(ServiceFactory serviceFactory) {

        serviceFactory.initialize();

        this.spatialIndexFactories.put(serviceFactory.getName(), serviceFactory);

    }

    @Override

    public Service createService(DynObject serviceParameters) throws ServiceException {

        throw new UnsupportedOperationException("Not supported yet.");

    }

    @Override

    public DynObject createServiceParameters(String serviceName) throws ServiceException {

        SpatialIndexFactory factory = this.getSpatialIndexFactory(serviceName);

        if (factory == null) {

            throw new CantExistsService(serviceName);

        }

        return factory.createParameters();

    }

    @Override

    public Service getService(DynObject parameters) throws ServiceException {

        return this.createSpatialIndex((String) parameters.getDynValue("serviceName"), parameters);

    }

    @Override

    public MultiPrimitive createMultiPrimitive(GeometryType geometryType) throws CreateGeometryException {

        int type = geometryType.getType();

        int subtype = geometryType.getSubType();

        if(isSubtype(Geometry.TYPES.POINT, type)){

            return createMultiPoint(subtype);

        }

        if(isSubtype(Geometry.TYPES.CURVE, type)){

            return createMultiCurve(subtype);

        }

        if(isSubtype(Geometry.TYPES.SURFACE, type)){

            return createMultiSurface(subtype);

        }

        throw new CreateGeometryException(type, subtype, null);

    }

    public class CantExistsService extends ServiceException {

        public CantExistsService(String serviceName) {

            super("Can't existe service %(service).", "_Cant_existe_service_XserviceX", 100001);

            setValue("service", serviceName);

        }

    }

    @Override

    public InformationbuilderWithGeometrySupport createInformacionBuilder() {

        return new BaseInformationBuilderWithGeometrySupport();

    }

    @Override

    public boolean isSubtype(int geomTypeParent, int geomTypeChild) {

        // Esto es un implementacion patatera que habria que mejorar,

        // pero mejor aqui que esparcida por todas partes en donde se

        // necesite.

        if( geomTypeParent == geomTypeChild ) {

            return true;

        }

        if( geomTypeParent == Geometry.TYPES.GEOMETRY ) {

            return true;

        }

        switch(geomTypeParent) {

        case Geometry.TYPES.MULTICURVE:

            return geomTypeChild==Geometry.TYPES.MULTILINE ;

        case Geometry.TYPES.MULTISURFACE:

            return geomTypeChild==Geometry.TYPES.MULTIPOLYGON ;

        case Geometry.TYPES.MULTIPOINT:

            return geomTypeChild==Geometry.TYPES.MULTIPOINT ;

        case Geometry.TYPES.CURVE:

            return

                geomTypeChild == Geometry.TYPES.CURVE ||

                geomTypeChild == Geometry.TYPES.LINE ||

                geomTypeChild == Geometry.TYPES.ARC ||

                geomTypeChild == Geometry.TYPES.SPLINE ||

                geomTypeChild == Geometry.TYPES.CIRCUMFERENCE ||

                geomTypeChild == Geometry.TYPES.PERIELLIPSE

                ;

        case Geometry.TYPES.SURFACE:

            return

            geomTypeChild==Geometry.TYPES.SURFACE ||

            geomTypeChild==Geometry.TYPES.POLYGON ||

            geomTypeChild == Geometry.TYPES.CIRCLE ||

            geomTypeChild == Geometry.TYPES.ELLIPSE ||

            geomTypeChild == Geometry.TYPES.RING ||

            geomTypeChild == Geometry.TYPES.FILLEDSPLINE ||

            geomTypeChild == Geometry.TYPES.ELLIPTICARC

            ;

        case Geometry.TYPES.POINT:

            return geomTypeChild==Geometry.TYPES.POINT ;

        }

        return false;

    }

    @Override

    public boolean canAggregate(int geomTypeParent, int geomTypeChild) {

        switch(geomTypeParent) {

        case Geometry.TYPES.MULTICURVE:

        case Geometry.TYPES.MULTILINE:

            return isSubtype(Geometry.TYPES.CURVE, geomTypeChild);

        case Geometry.TYPES.MULTISURFACE:

        case Geometry.TYPES.MULTIPOLYGON:

            return isSubtype(Geometry.TYPES.SURFACE, geomTypeChild);

        case Geometry.TYPES.MULTIPOINT:

            return isSubtype(Geometry.TYPES.POINT, geomTypeChild);

        }

        return false;

    }

    @Override

    public GeometryCoercionContext createGeometryCoercionContext() {

        return new DefaultGeometryCoercionContext();

    }

    public static void main(String[] args) throws GeometryException, GeometryOperationNotSupportedException, GeometryOperationException {

        String s;

        new DefaultLibrariesInitializer().fullInitialize();

//        s =  GeometryUtils.formatCoordinate("%-%d? %m' %s'' N", 39.89);

//        System.out.println(s);

//        s =  GeometryUtils.formatCoordinate("%-%d? %m' %.0s'' N", 39.89);

//        System.out.println(s);

//        s =  GeometryUtils.formatCoordinate("%+%d? %m' %.2s'' N (%4.4D)", 39.89);

//        System.out.println(s);

//        s =  GeometryUtils.formatCoordinate("%-%d? %m' N", -39.89);

//        System.out.println(s);

//        s =  GeometryUtils.formatCoordinate("%-%d? %m' N (%4.4D)", 39.89);

//        System.out.println(s);

        //Geometry g = GeometryUtils.createFrom("00000007d50000000100000007d20000002341258d57c2b73acf4150bf008a45b87241258d5eb2faa5364150befedb0f995841258d6aeb851eb84150befbeeb851ec41258d723d70a3d74150bef9d51eb85241258d7e428f5c294150bef677ae147b41258d9d147ae1484150beeea47ae14841258dbc28f5c28f4150bee72ae147ae41258dc7ae147ae14150bee468f5c28f41258dcc6b851eb84150bee31999999a41258dd1666666664150bee18b851eb841258dd8d70a3d714150bedf1d70a3d741258ddea8f5c28f4150bedc951eb85241258de3eb851eb84150bed99ccccccd41258dea3d70a3d74150bed6351eb85241258defbd70a3d74150bed3728f5c2941258df39999999a4150bed1751eb85241258df6c7ae147b4150bed01c28f5c341258df86b851eb84150becf1f5c28f641258dfa1999999a4150becd4666666641258dfb6147ae144150becbc51eb85241258dfd1999999a4150bec9a000000041258dfec28f5c294150bec753d70a3d41258e001eb851ec4150bec2f666666641258e047ae147ae4150beb73147ae1441258e054ccccccd4150beb3bc28f5c341258e054ccccccd4150beb2d70a3d7141258e05947ae1484150beb2047ae14841258e053d70a3d74150beb17333333341258e03a8f5c28f4150beb0e47ae14841258de69999999a4150beaca3d70a3d41258db10f5c28f64150bea46d70a3d741258dabdc28f5c34150bea3928f5c2941258da8dc28f5c34150bea300a3d70a41258da623d70a3d4150bea26147ae1441258da34ccccccd4150bea19d70a3d7");

        //Geometry g = GeometryUtils.createFrom("MULTILINESTRING M ((745920.412801 4319733.74841197 -9999,745923.444481 4319733.242374 -9999,745930.962949 4319734.760282 -9999,745937.102608 4319738.899755 -9999,745941.242081 4319745.039415 -9999,745942.759989 4319752.557882 -9999,745941.242081 4319760.07635 -9999,745937.102608 4319766.216009 -9999,745930.962949 4319770.355482 -9999,745923.444481 4319771.87339 -9999,745915.926014 4319770.355482 -9999,745914.042603266 4319769.08565144 -9999,745911.2302267 4319767.2327453 -9999))");

        Geometry g = GeometryUtils.createFrom("0105000060E66400000100000001020000400D00000016A75AD380C3264156FBE56F7D7A5041000000008087C3C07D0393E386C326413D0E834F7D7A5041000000008087C3C0BDA607ED95C32641D575A8B07D7A5041000000008087C3C029098934A2C32641FF9595B97E7A5041000000008087C3C0740AF27BAAC326417EC68542807A5041000000008087C3C039471D85ADC32641B456B423827A5041000000008087C3C0740AF27BAAC326411CEBE204847A5041000000008087C3C029098934A2C326416A17D38D857A5041000000008087C3C0BDA607ED95C326419337C096867A5041000000008087C3C07D0393E386C326412C9FE5F7867A5041000000008087C3C0CB811EDA77C326419337C096867A5041000000008087C3C06518D01574C3264130507B45867A5041000000008087C3C02646E0756EC32641894CE5CE857A5041000000008087C3C0");

        String hexwkb = g.convertToHexWKB();

        String hexewkb = g.convertToHexEWKB();

        //byte[] b = g.convertToEWKB();

        System.out.println(hexwkb);

        System.out.println(hexewkb);

    }

}