| gvSIG desktop 1

/* gvSIG. Sistema de Informaci?n Geogr?fica de la Generalitat Valenciana

 *

 * Copyright (C) 2006 Prodevelop and Generalitat Valenciana.

 *

 * 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., 59 Temple Place - Suite 330, Boston, MA  02111-1307,USA.

 *

 * For more information, contact:

 *

 *   Generalitat Valenciana

 *   Conselleria d'Infraestructures i Transport

 *   Av. Blasco Ib??ez, 50

 *   46010 VALENCIA

 *   SPAIN

 *

 *   +34 963862235

 *   gvsig@gva.es

 *   www.gvsig.gva.es

 *

 *    or

 *

 *   Prodevelop Integraci?n de Tecnolog?as SL

 *   Conde Salvatierra de ?lava , 34-10

 *   46004 Valencia

 *   Spain

 *

 *   +34 963 510 612

 *   +34 963 510 968

 *   gis@prodevelop.es

 *   http://www.prodevelop.es

 */

package es.prodevelop.cit.gvsig.fmap.drivers.jdbc.oracle;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

import com.vividsolutions.jts.algorithm.CGAlgorithms;

import com.vividsolutions.jts.geom.Coordinate;

import com.vividsolutions.jts.geom.CoordinateArrays;

import com.vividsolutions.jts.geom.Envelope;

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;

import oracle.sql.ARRAY;

import oracle.sql.Datum;

import oracle.sql.NUMBER;

import oracle.sql.STRUCT;

import oracle.sql.StructDescriptor;

import org.apache.log4j.Logger;

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

import java.text.DecimalFormat;

import java.text.DecimalFormatSymbols;

import java.util.ArrayList;

import java.util.Random;

/**

 * Utility class with static methods.

 *

 * @author jldominguez

 *

 */

public class OracleSpatialUtils {

    private static Logger logger = Logger.getLogger(OracleSpatialUtils.class.getName());

    private static double FLATNESS = 0.8;

    private static GeometryFactory geomFactory = new GeometryFactory();

    private static final double IRRELEVANT_DISTANCE = 0.00000001;

    private static Random rnd = new Random();

    private static DecimalFormat df = new DecimalFormat();

    private static DecimalFormatSymbols dfs = new DecimalFormatSymbols();

    public static final int ORACLE_GTYPE_UNKNOWN = 0;

    public static final int ORACLE_GTYPE_POINT = 1;

    public static final int ORACLE_GTYPE_LINE = 2;

    public static final int ORACLE_GTYPE_POLYGON = 3;

    public static final int ORACLE_GTYPE_COLLECTION = 4;

    public static final int ORACLE_GTYPE_MULTIPOINT = 5;

    public static final int ORACLE_GTYPE_MULTILINE = 6;

    public static final int ORACLE_GTYPE_MULTIPOLYGON = 7;

    /**

     * 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

     */

    public static IGeometry readGeometry3D(URL filepath, boolean polygon) {

        GeneralPathX resp = new GeneralPathX();

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

        ArrayList z = new ArrayList();

        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) {

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

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

                    }

                    else {

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

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

                    }

                    move = false;

                }

                line = br.readLine();

            }

        }

        catch (Exception ex) {

            System.err.println("Error while creating GeneralPathX: " +

                ex.getMessage());

            return null;

        }

        double[] zz = new double[z.size()];

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

            zz[i] = ((Double) z.get(i)).doubleValue();

        }

        if (polygon) {

            return ShapeFactory.createPolygon3D(resp, zz);

        }

        else {

            return ShapeFactory.createPolyline3D(resp, zz);

        }

    }

    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;

    }

    /**

     * Utility method to convert a gvSIG FShape into a oracle struct

     *

     * @param fshp the FShape object

     * @param c the connection

     * @param srid the SRS (oarcle code)

     * @param agu_b whether to check holes validity

     * @param hasSrid whether the SRS is non-NULL

     * @return a oracle struct representing the geometry

     *

     * @throws SQLException

     */

    public static STRUCT fShapeToSTRUCT(Object fshp, Connection c, int srid,

        boolean agu_b, boolean hasSrid) throws SQLException {

        boolean three = false;

        if (fshp instanceof FShape3D) {

            three = true;

        }

        STRUCT resp = null;

        if (fshp instanceof FMultiPoint2D) {

            resp = multiPoint2DToStruct((FMultiPoint2D) fshp, c, srid, hasSrid);

            return resp;

        }

        if (!(fshp instanceof FShape)) {

            logger.error("Unknown geometry: " + fshp.toString());

            return null;

        }

        if (fshp instanceof FPoint2D) { // point 2/3d

            // resp = pointToWKT((FPoint2D) fshp, three);

            Coordinate p = getSingleCoordinate((FPoint2D) fshp);

            resp = getMultiPointAsStruct(p, srid, three, c, hasSrid);

        }

        else {

            if (fshp instanceof FPolygon2D) { // polygon 2/3d

                if (fshp instanceof FCircle2D) {

                    resp = getCircleAsStruct((FCircle2D) fshp, srid, c, hasSrid);

                }

                else {

                    // also FEllipse2D

                    resp = getMultiPolygonAsStruct((FShape) fshp, srid, three,

                            c, agu_b, hasSrid);

                    // ArrayList polys = getPolygonsEasily(fshp);

                    // resp = getMultiPolygonAsStruct(polys, srid, three, c);

                }

            }

            else { // line 2/3d

                ArrayList _lines = getLineStrings((FShape) fshp);

                resp = getMultiLineAsStruct(_lines, srid, three, c, hasSrid);

            }

        }

        return resp;

    }

    private static STRUCT multiPoint2DToStruct(FMultiPoint2D mp2d,

        Connection c, int srid, boolean hasSrid) throws SQLException {

        int np = mp2d.getNumPoints();

        boolean threed = (mp2d instanceof FMultipoint3D);

        int gtype = 2005;

        int dim = 2;

        FMultipoint3D mp3d = null;

        if (threed) {

            gtype = 3005;

            dim = 3;

            mp3d = (FMultipoint3D) 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",

                c);

        Object[] obj = new Object[5];

        obj[0] = new NUMBER(gtype);

        if (hasSrid) {

            obj[1] = new NUMBER(srid);

        }

        else { // , boolean hasSrid

            obj[1] = null;

        }

        obj[2] = null;

        obj[3] = indices;

        obj[4] = ords;

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

        return resp;

    }

    private static STRUCT getCircleAsStruct(FCircle2D fcirc, int srid,

        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.getRadio());

        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(srid);

        }

        else {

            obj[1] = null;

        }

        obj[2] = null;

        obj[3] = indices;

        obj[4] = ords;

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

        return resp;

    }

    private static Coordinate[] getThreePointsOfCircumference(Point2D cntr,

        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 = cntr.getX() + (radius * Math.cos(alpha));

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

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

        }

        return resp;

    }

    private static Coordinate getSingleCoordinate(FPoint2D p2d) {

        // TODO Auto-generated method stub

        Coordinate resp = new Coordinate();

        resp.x = p2d.getX();

        resp.y = p2d.getY();

        if (p2d instanceof FPoint3D) {

            resp.z = ((FPoint3D) p2d).getZs()[0];

        }

        return resp;

    }

    private static ArrayList ensureSensibleLineString(ArrayList cc) {

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

            if (sameCoordinate((Coordinate) cc.get(0),

                        (Coordinate) cc.get(cc.size() - 1))) {

                ArrayList resp = new ArrayList();

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

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

                newc.x = newc.x + IRRELEVANT_DISTANCE;

                resp.add(newc);

                return resp;

            }

        }

        return cc;

    }

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

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

            return false;

        }

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

            return false;

        }

        return true;

    }

    private static ArrayList getClosedRelevantPolygon(ArrayList cc) {

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

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

        }

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

            if (sameCoordinate((Coordinate) cc.get(0), (Coordinate) cc.get(1))) {

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

            }

            if (sameCoordinate((Coordinate) cc.get(0), (Coordinate) cc.get(2))) {

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

            }

            if (sameCoordinate((Coordinate) cc.get(1), (Coordinate) cc.get(2))) {

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

            }

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

            return cc;

        }

        if (!sameCoordinate((Coordinate) cc.get(0),

                    (Coordinate) cc.get(cc.size() - 1))) {

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

        }

        return cc;

    }

    private static ArrayList getMinClosedCoords(Coordinate c) {

        ArrayList resp = new ArrayList();

        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;

    }

    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;

    }

    private static double[] getMinLinearRingZ() {

        double[] resp = new double[4];

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

            resp[i] = 0.0;

        return resp;

    }

    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))) //nan test; x!=x iff x is nan

            ) {

                return true;

            }

        }

        return false;

    }

    private static ArrayList getPolygonsEasily(FShape mpolygon) {

        boolean threed = false;

        if (mpolygon instanceof FPolygon3D) {

            threed = true;

        }

        int start_ind = 0;

        int end_ind = 0;

        int ind = 0;

        int new_size;

        ArrayList arrayCoords = null;

        ArrayList resp = new ArrayList();

        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();

                }

                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((FPolygon3D) 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) {

                            System.err.println("Topology exception: " +

                                e.getMessage());

                            return null;

                        }

                    }

                    arrayCoords = new ArrayList();

                    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:

                System.out.println("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:

                System.out.println("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:

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

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

                break;

            } //end switch

            theIterator.next();

        } //end while loop

        end_ind = ind - 1;

        // null shape:

        if (arrayCoords == null) {

            arrayCoords = new ArrayList();

            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((FPolygon3D) 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) {

                System.err.println("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;

    }

    private static double[] getZ(FShape3D p3d, int _str, int _end, int size) {

        double[] resp = new double[size];

        double[] allz = p3d.getZs();

        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;

    }

    private static ArrayList getLineStrings(FShape mlines) {

        boolean threed = false;

        if (mlines instanceof FPolyline3D) {

            threed = true;

        }

        int start_ind = 0;

        int end_ind = 0;

        int ind = 0;

        int new_size = 0;

        LineString3D lin;

        ArrayList arrayLines = new ArrayList();

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

        int theType = -99;

        double[] theData = new double[6];

        ArrayList arrayCoords = null;

        int numParts = 0;

        while (!theIterator.isDone()) {

            //while not done

            theType = theIterator.currentSegment(theData);

            switch (theType) {

            case PathIterator.SEG_MOVETO:

                // System.out.println("SEG_MOVETO");

                if (arrayCoords == null) {

                    arrayCoords = new ArrayList();

                }

                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((FPolyline3D) mlines, start_ind, end_ind,

                                new_size);

                    }

                    lin = new LineString3D(aux, z);

                    arrayLines.add(lin);

                    arrayCoords = new ArrayList();

                    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:

                System.out.println("Not supported here");

                break;

            case PathIterator.SEG_CUBICTO:

                System.out.println("Not supported here");

                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((FPolyline3D) mlines, start_ind, end_ind, new_size);

        }

        lin = new LineString3D(aux, z);

        arrayLines.add(lin);

        return arrayLines;

    }

    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;

    }

    private static String multiLineStringToWKT(ArrayList ml, boolean threed) {

        String resp = "MULTILINESTRING(";

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

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

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

        }

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

        return resp;

    }

    private static String polygonsToWKT(ArrayList pols, boolean threed) {

        String resp = "MULTIPOLYGON(";

        LineString3D ls = null;

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

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

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

        }

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

        return resp;

    }

    private static String shellAndHolesToWKT(LineString3D shell,

        ArrayList holes, boolean threed) {

        String resp = "(";

        resp = resp + lineStringToWKT(shell, threed);

        if (holes.size() > 0) {

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

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

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

            }

        }

        resp = resp + ")";

        return resp;

    }

    private static String multiPolygonToWKT(ArrayList shells, ArrayList hFs,

        boolean threed) {

        String resp = "MULTIPOLYGON(";

        LineString3D ls = null;

        ArrayList holes;

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

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

            holes = (ArrayList) hFs.get(i);

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

        }

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

        return resp;

    }

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

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

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

            resp = resp + " " + ((FPoint3D) point).getZs()[0];

        }

        resp = resp + ")";

        return resp;

    }

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

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

    }

    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;

    }

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

        Envelope env = ls.getEnvelopeInternal();

        if (!env.contains(p)) {

            return false;

        }

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

    }

    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;

        }

    }

    private static STRUCT getMultiPolygonAsStruct(ArrayList pols, int srid,

        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 * ((LineString3D) 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(srid);

        }

        else {

            obj[1] = null;

        }

        obj[2] = null;

        obj[3] = indices;

        obj[4] = ords;

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

        return resp;

    }

    private static STRUCT getMultiLineAsStruct(ArrayList lines, int srid,

        boolean threed, Connection _conn, boolean hasSrid)

        throws SQLException {

        /*

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

                return getOneLineStringAsStruct((LineString3D) lines.get(0), srid, threed, _conn);

        }

        */

        int size = lines.size();

        int geotype = 2006;

        int dim = 2;

        int acum = 0;

        if (threed) {

            geotype = 3006;

            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 * ((LineString3D) lines.get(i)).getLs().getNumPoints());

        }

        int _ind = 0;

        NUMBER[] ords = new NUMBER[acum];

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

            LineString3D ls = (LineString3D) 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(srid);

        }

        else {

            obj[1] = null;

        }

        obj[2] = null;

        obj[3] = indices;

        obj[4] = ords;

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

        return resp;

    }

    private static STRUCT getMultiPointAsStruct(Coordinate pnt, int srid,

        boolean threed, Connection _conn, boolean hasSrid)

        throws SQLException {

        int geotype = 2001;

        int dim = 2;

        if (threed) {

            geotype = 3001;

            dim = 3;

        }

        Object[] ords = new Object[3];

        ords[0] = new NUMBER(pnt.x);

        ords[1] = new NUMBER(pnt.y);

        ords[2] = (dim == 3) ? new NUMBER(pnt.z) : null; // ole ole y ole

        StructDescriptor ord_dsc = StructDescriptor.createDescriptor("MDSYS.SDO_POINT_TYPE",

                _conn);

        STRUCT ords_st = new STRUCT(ord_dsc, _conn, ords);

        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(srid);

        }

        else {

            obj[1] = null;

        }

        obj[2] = ords_st;

        obj[3] = null;

        obj[4] = null;

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

        return resp;

    }

    /**

     * Utility method to compute a circle's center and radius from three given points.

     *

     * @param points three points of a circumference

     * @return a 2-item array with the circumference's center (Point2D) and radius (Double)

     */

    public static Object[] getCenterAndRadiousOfCirc(Point2D[] points) {

        Object[] resp = new Object[2];

        resp[0] = new Point2D.Double(0, 0);

        resp[1] = new Double(0);

        double m11;

        double m12;

        double m13;

        double m14;

        if (points.length != 3) {

            logger.error("Needs 3 points (found " + points.length +

                ") - circle cannot be computed.");

            // not a circle

            return resp;

        }

        double[][] a = new double[3][3];

        for (int i = 0; i < 3; i++) { // find minor 11

            a[i][0] = points[i].getX();

            a[i][1] = points[i].getY();

            a[i][2] = 1;

        }

        m11 = determinant(a, 3);

        for (int i = 0; i < 3; i++) { // find minor 12 

            a[i][0] = (points[i].getX() * points[i].getX()) +

                (points[i].getY() * points[i].getY());

            a[i][1] = points[i].getY();

            a[i][2] = 1;

        }

        m12 = determinant(a, 3);

        for (int i = 0; i < 3; i++) // find minor 13

         {

            a[i][0] = (points[i].getX() * points[i].getX()) +

                (points[i].getY() * points[i].getY());

            a[i][1] = points[i].getX();

            a[i][2] = 1;

        }

        m13 = determinant(a, 3);

        for (int i = 0; i < 3; i++) { // find minor 14

            a[i][0] = (points[i].getX() * points[i].getX()) +

                (points[i].getY() * points[i].getY());

            a[i][1] = points[i].getX();

            a[i][2] = points[i].getY();

        }

        m14 = determinant(a, 3);

        Double resp_radius = new Double(0);

        Point2D resp_center = new Point2D.Double(0, 0);

        if (m11 == 0) {

            logger.error("Three points aligned - circle cannot be computed."); // not a circle

        }

        else {

            double x = (0.5 * m12) / m11;

            double y = (-0.5 * m13) / m11;

            resp_center.setLocation(x, y);

            resp_radius = new Double(Math.sqrt((x * x) + (y * y) + (m14 / m11)));

            resp[0] = resp_center;

            resp[1] = resp_radius;