| gvSIG desktop 1

/* gvSIG. Geographic Information System of the Valencian Government

 *

 * Copyright (C) 2007-2008 Infrastructures and Transports Department

 * of the Valencian Government (CIT)

 *

 * 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 2

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

 *

 */

/*

 * AUTHORS (In addition to CIT):

 * 2009 Prodevelop S.L. main development

 */

package org.gvsig.fmap.dal.store.oracle;

import java.awt.geom.PathIterator;

import java.awt.geom.Point2D;

import java.awt.geom.Rectangle2D;

import java.io.BufferedReader;

import java.io.File;

import java.io.FileReader;

import java.lang.reflect.Array;

import java.net.URL;

import java.sql.Connection;

import java.sql.PreparedStatement;

import java.sql.ResultSet;

import java.sql.SQLException;

import java.sql.Types;

import java.text.DecimalFormat;

import java.text.DecimalFormatSymbols;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.Iterator;

import java.util.List;

import java.util.Random;

import oracle.sql.ARRAY;

import oracle.sql.Datum;

import oracle.sql.NUMBER;

import oracle.sql.STRUCT;

import oracle.sql.StructDescriptor;

import org.cresques.cts.IProjection;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataManager;

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

import org.gvsig.fmap.dal.feature.EditableFeatureType;

import org.gvsig.fmap.dal.feature.Feature;

import org.gvsig.fmap.dal.feature.FeatureAttributeDescriptor;

import org.gvsig.fmap.dal.feature.FeatureQuery;

import org.gvsig.fmap.dal.feature.FeatureSet;

import org.gvsig.fmap.dal.feature.FeatureStore;

import org.gvsig.fmap.dal.feature.FeatureType;

import org.gvsig.fmap.dal.feature.spi.FeatureReferenceProviderServices;

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.GeometryLocator;

import org.gvsig.fmap.geom.GeometryManager;

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

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

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

import org.gvsig.fmap.geom.aggregate.impl.MultiPoint2D;

import org.gvsig.fmap.geom.aggregate.impl.MultiPoint2DZ;

import org.gvsig.fmap.geom.aggregate.impl.MultiSurface2D;

import org.gvsig.fmap.geom.complex.Complex;

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

import org.gvsig.fmap.geom.impl.DefaultGeometryManager;

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

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

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

import org.gvsig.fmap.geom.primitive.impl.Circle2D;

import org.gvsig.fmap.geom.primitive.impl.Curve2DZ;

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

import org.gvsig.fmap.geom.primitive.impl.Point2DZ;

import org.gvsig.fmap.geom.primitive.impl.Surface2D;

import org.gvsig.fmap.geom.primitive.impl.Surface2DZ;

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

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

import org.gvsig.oracle.extension.NewOracleTableExtension;

import org.gvsig.oracle.utils.LineString3D;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import com.vividsolutions.jts.algorithm.CGAlgorithms;

import com.vividsolutions.jts.geom.Coordinate;

import com.vividsolutions.jts.geom.CoordinateArrays;

import com.vividsolutions.jts.geom.GeometryFactory;

import com.vividsolutions.jts.geom.LineString;

import com.vividsolutions.jts.geom.LinearRing;

import com.vividsolutions.jts.geom.impl.CoordinateArraySequence;

/**

 * Utility class with static methods.

 * 

 * @author jldominguez, vsanjaime

 * 

 */

public class OracleUtils {

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

        private static double FLATNESS = 0.8;

        private static GeometryFactory geomFactory = new GeometryFactory();

        private static final double IRRELEVANT_DISTANCE = 0.00000001;

        public static final Rectangle2D DEFAULT_BBOX = new Rectangle2D.Double(-180, -90, 360, 180);;

        private static Random rnd = new Random();

        private static DecimalFormat df = new DecimalFormat();

        private static DecimalFormatSymbols dfs = new DecimalFormatSymbols();

        public static final String ENVELOPE_ID = "Envelope_Key";

        public static final String DIMENSIONS_ID = "Dimensions_Key";

    private static final String GEOM_DEFAULT_TOL = "0.000005";

        /**

         * COnstructs a geometry from a file that contains a vertex per line:

         * 

         * x1 y1 z1 x2 y2 z2 ...

         * 

         * @param filepath

         *            vertices text file path

         * @param polygon

         *            whether it is a polygon or not

         * @return the created geometry

         * @throws CreateGeometryException

         */

        public static Geometry readGeometry3D(URL filepath, boolean polygon)

                        throws CreateGeometryException {

                GeometryManager geomManager = GeometryLocator.getGeometryManager();

                GeneralPathX gpx = new GeneralPathX();

                File file = new File(filepath.getFile());

                List<Double> z = new ArrayList<Double>();

                try {

                        FileReader fr = new FileReader(file);

                        BufferedReader br = new BufferedReader(fr);

                        double[] coords = new double[3];

                        boolean move = true;

                        String line = br.readLine();

                        while (line != null) {

                                coords = parseLine(line);

                                if (line.length() == 0) {

                                        move = true;

                                } else {

                                        if (move) {

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

                                                z.add(new Double(coords[2]));

                                        } else {

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

                                                z.add(new Double(coords[2]));

                                        }

                                        move = false;

                                }

                                line = br.readLine();

                        }

                } catch (Exception ex) {

                        logger.error("While creating GeneralPathX: " + ex.getMessage());

                        return null;

                }

                if (polygon) {

                        Surface surface = (Surface) geomManager.create(

                                        Geometry.TYPES.SURFACE, Geometry.SUBTYPES.GEOM3D);

                        surface.setGeneralPath(gpx);

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

                                surface

                                                .setCoordinateAt(i, 2, ((Double) z.get(i))

                                                                .doubleValue());

                        }

                        return surface;

                } else {

                        Curve curve = (Curve) geomManager.create(Geometry.TYPES.CURVE,

                                        Geometry.SUBTYPES.GEOM3D);

                        curve.setGeneralPath(gpx);

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

                                curve.setCoordinateAt(i, 2, ((Double) z.get(i)).doubleValue());

                        }

                        return curve;

                }

        }

        /**

         * 

         * @param line

         * @return

         */

        private static double[] parseLine(String line) {

                String[] sep = line.split(" ");

                double[] resp = new double[3];

                for (int i = 0; i < 3; i++)

                        resp[i] = 0.0;

                try {

                        resp[0] = Double.parseDouble(sep[0]);

                } catch (Exception ex) {

                }

                if (sep.length > 1) {

                        try {

                                resp[1] = Double.parseDouble(sep[1]);

                        } catch (Exception ex) {

                        }

                        if (sep.length > 2) {

                                try {

                                        resp[2] = Double.parseDouble(sep[2]);

                                } catch (Exception ex) {

                                }

                        }

                }

                return resp;

        }

        /**

         * Transform multipoint2d or multipoint2dz to Oracle STRUCT

         * 

         * @param mp2d

         * @param conn

         * @param osrid

         * @param hasSrid

         * @return

         * @throws SQLException

         */

        private static STRUCT multiPoint2DToStruct(MultiPoint2D mp2d,

                        Connection conn, int osrid, boolean hasSrid) throws SQLException {

                int np = mp2d.getPrimitivesNumber();

                boolean threed = (mp2d instanceof MultiPoint2DZ);

                int gtype = 2005;

                int dim = 2;

                MultiPoint2DZ mp3d = null;

                if (threed) {

                        gtype = 3005;

                        dim = 3;

                        mp3d = (MultiPoint2DZ) mp2d;

                }

                NUMBER[] indices = new NUMBER[3];

                indices[0] = new NUMBER(1);

                indices[1] = new NUMBER(1);

                indices[2] = new NUMBER(np);

                NUMBER[] ords = new NUMBER[dim * np];

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

                        ords[dim * i] = new NUMBER(mp2d.getPoint(i).getX());

                        ords[(dim * i) + 1] = new NUMBER(mp2d.getPoint(i).getY());

                        if (threed) {

                                ords[(dim * i) + 2] = new NUMBER(mp3d.getZs()[i]);

                        }

                }

                STRUCT resp;

                StructDescriptor dsc = StructDescriptor.createDescriptor(

                                "MDSYS.SDO_GEOMETRY", conn);

                Object[] obj = new Object[5];

                obj[0] = new NUMBER(gtype);

                if (hasSrid) {

                        obj[1] = new NUMBER(osrid);

                } else { // , boolean hasSrid

                        obj[1] = null;

                }

                obj[2] = null;

                obj[3] = indices;

                obj[4] = ords;

                resp = new STRUCT(dsc, conn, obj);

                return resp;

        }

        /**

         * Transform circle2d to Oracle STRUCT

         * 

         * @param fcirc

         * @param osrid

         * @param _conn

         * @param hasSrid

         * @return

         * @throws SQLException

         */

        private static STRUCT getCircleAsStruct(Circle2D fcirc, int osrid,

                        Connection conn, boolean hasSrid) throws SQLException {

                int geotype = 2003;

                NUMBER[] indices = new NUMBER[3];

                indices[0] = new NUMBER(1);

                indices[1] = new NUMBER(1003);

                indices[2] = new NUMBER(4);

                NUMBER[] ords = new NUMBER[6];

                Coordinate[] three_points = getThreePointsOfCircumference(fcirc

                                .getCenter(), fcirc.getRadious());

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

                        ords[i * 2] = new NUMBER(three_points[i].x);

                        ords[(i * 2) + 1] = new NUMBER(three_points[i].y);

                }

                STRUCT resp;

                StructDescriptor dsc = StructDescriptor.createDescriptor(

                                "MDSYS.SDO_GEOMETRY", conn);

                Object[] obj = new Object[5];

                obj[0] = new NUMBER(geotype);

                if (hasSrid) {

                        obj[1] = new NUMBER(osrid);

                } else {

                        obj[1] = null;

                }

                obj[2] = null;

                obj[3] = indices;

                obj[4] = ords;

                resp = new STRUCT(dsc, conn, obj);

                return resp;

        }

        /**

         * 

         * @param center

         * @param radius

         * @return

         */

        private static Coordinate[] getThreePointsOfCircumference(Point center,

                        double radius) {

                Coordinate[] resp = new Coordinate[3];

                double x;

                double y;

                double alpha = 0;

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

                        alpha = (i * 120.0 * Math.PI) / 180.0;

                        x = center.getX() + (radius * Math.cos(alpha));

                        y = center.getY() + (radius * Math.sin(alpha));

                        resp[i] = new Coordinate(x, y);

                }

                return resp;

        }

        /**

         * Get coordinates from a point

         * 

         * @param pto

         * @return

         */

        private static Coordinate getSingleCoordinate(Point pto) {

                Coordinate resp = new Coordinate();

                resp.x = pto.getX();

                resp.y = pto.getY();

                if (pto instanceof Point2DZ) {

                        resp.z = ((Point2DZ) pto).getCoordinateAt(3);

                }

                return resp;

        }

        /**

         * 

         * @param cc

         * @return

         */

        private static List<Coordinate> ensureSensibleLineString(List<Coordinate> cc) {

                if (cc.size() == 2) {

                        if (same2DCoordinate(cc.get(0), cc.get(cc.size() - 1))) {

                                List<Coordinate> resp = new ArrayList<Coordinate>();

                                resp.add(cc.get(0));

                                Coordinate newc = new Coordinate(cc.get(0));

                                newc.x = newc.x + IRRELEVANT_DISTANCE;

                                resp.add(newc);

                                return resp;

                        }

                }

                return cc;

        }

        /**

         * 

         * @param c1

         * @param c2

         * @return

         */

        private static boolean same2DCoordinate(Coordinate c1, Coordinate c2) {

                if (c1.x != c2.x) {

                        return false;

                }

                if (c1.y != c2.y) {

                        return false;

                }

                return true;

        }

        /**

         * 

         * @param cc

         * @return

         */

        private static List<Coordinate> getClosedRelevantPolygon(List<Coordinate> cc) {

                if (cc.size() == 2) {

                        return getMinClosedCoords(cc.get(0));

                }

                if (cc.size() == 3) {

                        if (same2DCoordinate(cc.get(0), cc.get(1))) {

                                return getMinClosedCoords(cc.get(0));

                        }

                        if (same2DCoordinate(cc.get(0), cc.get(2))) {

                                return getMinClosedCoords((Coordinate) cc.get(0));

                        }

                        if (same2DCoordinate(cc.get(1), cc.get(2))) {

                                return getMinClosedCoords(cc.get(1));

                        }

                        cc.add(cc.get(0));

                        return cc;

                }

                if (!same2DCoordinate(cc.get(0), cc.get(cc.size() - 1))) {

                        cc.add(cc.get(0));

                }

                return cc;

        }

        /**

         * 

         * @param c

         * @return

         */

        private static List<Coordinate> getMinClosedCoords(Coordinate c) {

                List<Coordinate> resp = new ArrayList<Coordinate>();

                resp.add(c);

                Coordinate nc = new Coordinate(c);

                nc.x = nc.x + IRRELEVANT_DISTANCE;

                resp.add(nc);

                Coordinate nc2 = new Coordinate(nc);

                nc2.y = nc2.y + IRRELEVANT_DISTANCE;

                resp.add(nc2);

                resp.add(new Coordinate(c));

                return resp;

        }

        /**

         * 

         * @param c

         * @return

         */

        private static LinearRing getMinLinearRing(Coordinate c) {

                Coordinate[] p = new Coordinate[4];

                p[0] = c;

                Coordinate nc = new Coordinate(c);

                nc.x = nc.x + IRRELEVANT_DISTANCE;

                Coordinate nc2 = new Coordinate(nc);

                nc2.y = nc2.y - IRRELEVANT_DISTANCE;

                p[1] = nc;

                p[2] = nc2;

                p[3] = new Coordinate(c);

                CoordinateArraySequence cs = new CoordinateArraySequence(p);

                LinearRing ls = new LinearRing(cs, geomFactory);

                return ls;

        }

        /**

         * 

         * @return

         */

        private static double[] getMinLinearRingZ() {

                double[] resp = new double[4];

                for (int i = 0; i < 4; i++)

                        resp[i] = 0.0;

                return resp;

        }

        /**

         * 

         * @param testPoint

         * @param pointList

         * @return

         */

        private static boolean pointInList(Coordinate testPoint,

                        Coordinate[] pointList) {

                int t;

                int numpoints;

                Coordinate p;

                numpoints = Array.getLength(pointList);

                for (t = 0; t < numpoints; t++) {

                        p = pointList[t];

                        if ((testPoint.x == p.x)

                                        && (testPoint.y == p.y)

                                        && ((testPoint.z == p.z) || (!(testPoint.z == testPoint.z)))) {

                                return true;

                        }

                }

                return false;

        }

        /***

         * 

         * @param mpolygon

         * @return

         */

        private static List<LineString3D> getPolygonsEasily(Geometry mpolygon) {

                boolean threed = false;

                if (mpolygon instanceof Surface2DZ) {

                        threed = true;

                }

                int start_ind = 0;

                int end_ind = 0;

                int ind = 0;

                int new_size;

                List<Coordinate> arrayCoords = null;

                List<LineString3D> resp = new ArrayList<LineString3D>();

                Coordinate[] points = null;

                int theType = -99;

                double[] theData = new double[6];

                Coordinate onlyCoord = null;

                int numParts = 0;

                PathIterator theIterator = mpolygon.getPathIterator(null, FLATNESS);

                while (!theIterator.isDone()) {

                        // while not done

                        theType = theIterator.currentSegment(theData);

                        if (onlyCoord == null) {

                                onlyCoord = new Coordinate();

                                onlyCoord.x = theData[0];

                                onlyCoord.y = theData[1];

                        }

                        switch (theType) {

                        case PathIterator.SEG_MOVETO:

                                if (arrayCoords == null) {

                                        arrayCoords = new ArrayList<Coordinate>();

                                } else {

                                        end_ind = ind - 1;

                                        arrayCoords = getClosedRelevantPolygon(arrayCoords);

                                        new_size = arrayCoords.size();

                                        if (arrayCoords != null) {

                                                points = CoordinateArrays

                                                                .toCoordinateArray(arrayCoords);

                                                try {

                                                        LinearRing aux = geomFactory

                                                                        .createLinearRing(points);

                                                        double[] z = null;

                                                        if (threed) {

                                                                z = getZ((Surface2DZ) mpolygon, start_ind,

                                                                                end_ind, new_size);

                                                        }

                                                        LineString3D ring = new LineString3D(aux, z);

                                                        if (CGAlgorithms.isCCW(points)) {

                                                                resp.add(ring);

                                                        } else {

                                                                resp.add(ring.createReverse());

                                                        }

                                                } catch (Exception e) {

                                                        logger.error("Topology exception: "

                                                                        + e.getMessage());

                                                        return null;

                                                }

                                        }

                                        arrayCoords = new ArrayList<Coordinate>();

                                        start_ind = ind;

                                }

                                numParts++;

                                arrayCoords.add(new Coordinate(theData[0], theData[1]));

                                ind++;

                                break;

                        case PathIterator.SEG_LINETO:

                                arrayCoords.add(new Coordinate(theData[0], theData[1]));

                                ind++;

                                break;

                        case PathIterator.SEG_QUADTO:

                                logger.info("SEG_QUADTO Not supported here");

                                arrayCoords.add(new Coordinate(theData[0], theData[1]));

                                arrayCoords.add(new Coordinate(theData[2], theData[3]));

                                ind++;

                                ind++;

                                break;

                        case PathIterator.SEG_CUBICTO:

                                logger.info("SEG_CUBICTO Not supported here");

                                arrayCoords.add(new Coordinate(theData[0], theData[1]));

                                arrayCoords.add(new Coordinate(theData[2], theData[3]));

                                arrayCoords.add(new Coordinate(theData[4], theData[5]));

                                ind++;

                                ind++;

                                ind++;

                                break;

                        case PathIterator.SEG_CLOSE:

                                break;

                        }

                        theIterator.next();

                }

                end_ind = ind - 1;

                // null shape:

                if (arrayCoords == null) {

                        arrayCoords = new ArrayList<Coordinate>();

                        Coordinate _c = new Coordinate(0, 0, 0);

                        arrayCoords.add(new Coordinate(_c));

                        arrayCoords.add(new Coordinate(_c));

                }

                // --------------------------------------------

                arrayCoords = getClosedRelevantPolygon(arrayCoords);

                new_size = arrayCoords.size();

                if (arrayCoords != null) {

                        points = CoordinateArrays.toCoordinateArray(arrayCoords);

                        try {

                                LinearRing aux = geomFactory.createLinearRing(points);

                                double[] z = null;

                                if (threed) {

                                        z = getZ((Surface2DZ) mpolygon, start_ind, end_ind,

                                                        new_size);

                                }

                                LineString3D ring = new LineString3D(aux, z);

                                if (CGAlgorithms.isCCW(points)) {

                                        resp.add(ring);

                                } else {

                                        resp.add(ring.createReverse());

                                }

                        } catch (Exception e) {

                                logger.error("Topology exception: " + e.getMessage());

                                return null;

                        }

                }

                if (resp.size() == 0) {

                        resp.add(new LineString3D(getMinLinearRing(onlyCoord),

                                        getMinLinearRingZ()));

                }

                return resp;

        }

        /**

         * Utility method to reverse an array of doubles.

         * 

         * @param _z

         *            an array of doubles to be reversed.

         * 

         * @return the reversed array of doubles

         */

        public static double[] reverseArray(double[] _z) {

                int size = _z.length;

                double[] resp = new double[size];

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

                        resp[i] = _z[size - 1 - i];

                }

                return resp;

        }

        /**

         * Utility method to reverse an array of coordinates

         * 

         * @param _z

         *            an array of coordinaes to be reversed.

         * 

         * @return the reversed array of coordinates

         */

        public static Coordinate[] reverseCoordinateArray(Coordinate[] _z) {

                int size = _z.length;

                Coordinate[] resp = new Coordinate[size];

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

                        resp[i] = _z[size - 1 - i];

                }

                return resp;

        }

        /**

         * 

         * @param geom

         * @param _str

         * @param _end

         * @param size

         * @return

         */

        private static double[] getZ(Geometry geom, int _str, int _end, int size) {

                double[] resp = new double[size];

                double[] allz = new double[1];

                if (geom instanceof Point2DZ) {

                        allz[0] = ((Point2DZ) geom).getCoordinateAt(3);

                }

                if (geom instanceof Curve2DZ) {

                        Curve2DZ curve = (Curve2DZ) geom;

                        allz = new double[curve.getNumVertices()];

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

                                allz[i] = curve.getCoordinateAt(i, 3);

                        }

                }

                if (geom instanceof Surface2DZ) {

                        Surface2DZ surface = (Surface2DZ) geom;

                        allz = new double[surface.getNumVertices()];

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

                                allz[i] = surface.getCoordinateAt(i, 3);

                        }

                }

                for (int i = _str; ((i <= _end) && ((i - _str) < size)); i++) {

                        resp[i - _str] = allz[i];

                }

                if ((_end - _str + 1) < size) {

                        double repe = allz[_end];

                        for (int i = (_end - _str + 1); i < size; i++) {

                                resp[i] = repe;

                        }

                }

                return resp;

        }

        /**

         * 

         * @param mlines

         * @return

         */

        private static List<LineString3D> getLineStrings(Geometry mlines) {

                boolean threed = false;

                if (mlines instanceof Curve2DZ) {

                        threed = true;

                }

                int start_ind = 0;

                int end_ind = 0;

                int ind = 0;

                int new_size = 0;

                LineString3D lin;

                List<LineString3D> arrayLines = new ArrayList<LineString3D>();

                PathIterator theIterator = mlines.getPathIterator(null, FLATNESS);

                int theType = -99;

                double[] theData = new double[6];

                List<Coordinate> arrayCoords = null;

                int numParts = 0;

                while (!theIterator.isDone()) {

                        // while not done

                        theType = theIterator.currentSegment(theData);

                        switch (theType) {

                        case PathIterator.SEG_MOVETO:

                                if (arrayCoords == null) {

                                        arrayCoords = new ArrayList<Coordinate>();

                                } else {

                                        end_ind = ind - 1;

                                        arrayCoords = ensureSensibleLineString(arrayCoords);

                                        new_size = arrayCoords.size();

                                        LineString aux = geomFactory

                                                        .createLineString(CoordinateArrays

                                                                        .toCoordinateArray(arrayCoords));

                                        double[] z = null;

                                        if (threed) {

                                                z = getZ((Curve2DZ) mlines, start_ind, end_ind,

                                                                new_size);

                                        }

                                        lin = new LineString3D(aux, z);

                                        arrayLines.add(lin);

                                        arrayCoords = new ArrayList<Coordinate>();

                                        start_ind = ind;

                                }

                                numParts++;

                                arrayCoords.add(new Coordinate(theData[0], theData[1]));

                                break;

                        case PathIterator.SEG_LINETO:

                                arrayCoords.add(new Coordinate(theData[0], theData[1]));

                                break;

                        case PathIterator.SEG_QUADTO:

                                logger.info("Not supported here: SEG_QUADTO");

                                break;

                        case PathIterator.SEG_CUBICTO:

                                logger.info("Not supported here: SEG_CUBICTO");

                                break;

                        case PathIterator.SEG_CLOSE:

                                Coordinate firstCoord = (Coordinate) arrayCoords.get(0);

                                arrayCoords.add(new Coordinate(firstCoord.x, firstCoord.y));

                                break;

                        } // end switch

                        theIterator.next();

                        ind++;

                } // end while loop

                arrayCoords = ensureSensibleLineString(arrayCoords);

                new_size = arrayCoords.size();

                LineString aux = geomFactory.createLineString(CoordinateArrays

                                .toCoordinateArray(arrayCoords));

                double[] z = null;

                if (threed) {

                        z = getZ((Curve2DZ) mlines, start_ind, end_ind, new_size);

                }

                lin = new LineString3D(aux, z);

                arrayLines.add(lin);

                return arrayLines;

        }

        /**

         * 

         * @param ls

         * @param threed

         * @return

         */

        private static String lineStringToWKT(LineString3D ls, boolean threed) {

                String resp = "(";

                Coordinate[] cc = ls.getLs().getCoordinates();

                double[] z = ls.getZc();

                int size = cc.length;

                if (threed) {

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

                                resp = resp + cc[i].x + " " + cc[i].y + " " + z[i] + ", ";

                        }

                        resp = resp.substring(0, resp.length() - 2);

                        resp = resp + ")";

                } else {

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

                                resp = resp + cc[i].x + " " + cc[i].y + ", ";

                        }

                        resp = resp.substring(0, resp.length() - 2);

                        resp = resp + ")";

                }

                return resp;

        }

        /**

         * 

         * @param ml

         * @param threed

         * @return

         */

        private static String multiLineStringToWKT(List<LineString3D> ml,

                        boolean threed) {

                String resp = "MULTILINESTRING(";

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

                        LineString3D ls = ml.get(i);

                        resp = resp + lineStringToWKT(ls, threed) + ", ";

                }

                resp = resp.substring(0, resp.length() - 2) + ")";

                return resp;

        }

        /**

         * 

         * @param pols

         * @param threed

         * @return

         */

        private static String polygonsToWKT(List<LineString3D> pols, boolean threed) {

                String resp = "MULTIPOLYGON(";

                LineString3D ls = null;

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

                        ls = pols.get(i);

                        resp = resp + "(" + lineStringToWKT(ls, threed) + "), ";

                }

                resp = resp.substring(0, resp.length() - 2) + ")";

                return resp;

        }

        /**

         * 

         * @param shell

         * @param holes

         * @param threed

         * @return

         */

        private static String shellAndHolesToWKT(LineString3D shell,

                        List<LineString3D> holes, boolean threed) {

                String resp = "(";

                resp = resp + lineStringToWKT(shell, threed);

                if (holes.size() > 0) {

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

                                LineString3D ls = holes.get(i);

                                resp = resp + ", " + lineStringToWKT(ls, threed);

                        }

                }

                resp = resp + ")";

                return resp;

        }

        /**

         * 

         * @param shells

         * @param hFs

         * @param threed

         * @return

         */

        private static String multiPolygonToWKT(List<LineString3D> shells,

                        List<List<LineString3D>> hFs, boolean threed) {

                String resp = "MULTIPOLYGON(";

                LineString3D ls = null;

                List<LineString3D> holes;

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

                        ls = shells.get(i);

                        holes = hFs.get(i);

                        resp = resp + shellAndHolesToWKT(ls, holes, threed) + ", ";

                }

                resp = resp.substring(0, resp.length() - 2) + ")";

                return resp;

        }

        /**

         * 

         * @param point

         * @param threed

         * @return

         */

        private static String pointToWKT(Point point, boolean threed) {

                String resp = "POINT(" + point.getX() + " " + point.getY();

                if ((threed) && (point instanceof Point2DZ)) {

                        resp = resp + " " + ((Point2DZ) point).getCoordinateAt(3);

                }

                resp = resp + ")";

                return resp;

        }

        /**

         * 

         * @param n

         * @param d

         * @return

         */

        private static int twoDIndexToDimsIndex(int n, int d) {

                return ((d * (n - 1)) / 2) + 1;

        }

        /**

         * 

         * @param old

         * @param d

         * @return

         * @throws SQLException

         */

        private static ARRAY setSubelementsToDim(ARRAY old, int d)

                        throws SQLException {

                Datum[] infos = (Datum[]) old.getOracleArray();

                for (int i = 3; i < infos.length; i = i + 3) {

                        int oldind = infos[i].intValue();

                        oldind = twoDIndexToDimsIndex(oldind, d);

                        infos[i] = new NUMBER(oldind);

                        //

                        oldind = infos[i + 1].intValue();

                        infos[i + 1] = new NUMBER(infos[1].intValue());

                }

                ARRAY resp = new ARRAY(old.getDescriptor(), old.getOracleConnection(),

                                infos);

                return resp;

        }

        /**

         * 

         * @param p

         * @param ls

         * @return

         */

        private static boolean isPointInsideLineString(Coordinate p, LineString ls) {

                com.vividsolutions.jts.geom.Envelope env = ls.getEnvelopeInternal();

                if (!env.contains(p)) {

                        return false;

                }

                return CGAlgorithms.isPointInRing(p, ls.getCoordinates());

        }

        /**

         * 

         * @param contained

         * @param container

         * @return

         */

        private static boolean lineString3DIsContainedBy(LineString3D contained,

                        LineString3D container) {

                int samples = 10;

                LineString _in = contained.getLs();

                LineString _out = container.getLs();

                Coordinate[] inc = _in.getCoordinates();

                Coordinate aux;

                int size = inc.length;

                if (size <= 10) {

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

                                aux = inc[i];

                                if (!isPointInsideLineString(aux, _out)) {

                                        return false;

                                }

                        }

                        return true;

                } else {

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

                                aux = inc[rnd.nextInt(size)];

                                if (!isPointInsideLineString(aux, _out)) {

                                        return false;

                                }

                        }

                        return true;

                }

        }

        /**

         * Transform multipolygons2d or 2dz to Oracle STRUCT

         * 

         * @param pols

         * @param srid

         * @param threed

         * @param _conn

         * @param agu_bien

         * @param hasSrid

         * @return

         * @throws SQLException

         */

        private static STRUCT getMultiPolygonAsStruct(List<LineString3D> pols,

                        int osrid, boolean threed, Connection conn, boolean agu_bien,

                        boolean hasSrid) throws SQLException {

                int size = pols.size();

                int geotype = 2007;

                int dim = 2;

                int acum = 0;

                if (threed) {

                        geotype = 3007;

                        dim = 3;

                }

                NUMBER[] indices = new NUMBER[3 * size];

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

                        indices[3 * i] = new NUMBER(acum + 1);

                        indices[(3 * i) + 1] = new NUMBER(1003);

                        indices[(3 * i) + 2] = new NUMBER(1);

                        acum = acum + (dim * (pols.get(i)).getLs().getNumPoints());

                }

                int _ind = 0;

                NUMBER[] ords = new NUMBER[acum];

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

                        LineString3D ls = (LineString3D) pols.get(i);

                        int num_p = ls.getLs().getNumPoints();

                        for (int j = 0; j < num_p; j++) {

                                ords[_ind] = new NUMBER(ls.getLs().getCoordinateN(j).x);

                                ords[_ind + 1] = new NUMBER(ls.getLs().getCoordinateN(j).y);

                                if (threed) {

                                        ords[_ind + 2] = new NUMBER(ls.getZc()[j]);

                                }

                                _ind = _ind + dim;

                        }

                }

                STRUCT resp;

                StructDescriptor dsc = StructDescriptor.createDescriptor(

                                "MDSYS.SDO_GEOMETRY", conn);

                Object[] obj = new Object[5];

                obj[0] = new NUMBER(geotype);

                if (hasSrid) {

                        obj[1] = new NUMBER(osrid);

                } else {

                        obj[1] = null;

                }

                obj[2] = null;

                obj[3] = indices;

                obj[4] = ords;

                resp = new STRUCT(dsc, conn, obj);

                return resp;

        }

        /**

         * 

         * @param lines

         * @param srid

         * @param threed

         * @param _conn

         * @param hasSrid

         * @return

         * @throws SQLException

         */

        private static STRUCT getMultiLineAsStruct(List<LineString3D> lines,

                        int osrid, boolean threed, Connection conn, boolean hasSrid)

                        throws SQLException {

                int size = lines.size();

                int geotype = 2006;

        if (size == 1) {

            geotype = 2002;

        }

                int dim = 2;

                int acum = 0;

                if (threed) {

                        geotype = 3006;

            if (size == 1) {

                geotype = 3002;

            }

                        dim = 3;

                }

                NUMBER[] indices = new NUMBER[3 * size];

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

                        indices[3 * i] = new NUMBER(acum + 1);

                        indices[(3 * i) + 1] = new NUMBER(2);

                        indices[(3 * i) + 2] = new NUMBER(1);

                        acum = acum + (dim * (lines.get(i)).getLs().getNumPoints());

                }

                int _ind = 0;

                NUMBER[] ords = new NUMBER[acum];

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

                        LineString3D ls = lines.get(i);

                        int num_p = ls.getLs().getNumPoints();

                        for (int j = 0; j < num_p; j++) {

                                ords[_ind] = new NUMBER(ls.getLs().getCoordinateN(j).x);

                                ords[_ind + 1] = new NUMBER(ls.getLs().getCoordinateN(j).y);

                                if (threed) {

                                        ords[_ind + 2] = new NUMBER(ls.getZc()[j]);

                                }

                                _ind = _ind + dim;

                        }

                }

                STRUCT resp;

                StructDescriptor dsc = StructDescriptor.createDescriptor(

                                "MDSYS.SDO_GEOMETRY", conn);

                Object[] obj = new Object[5];

                obj[0] = new NUMBER(geotype);

                if (hasSrid) {

                        obj[1] = new NUMBER(osrid);

                } else {

                        obj[1] = null;

                }