| gvSIG desktop 1

/*

 * Created on 02-jun-2005

 *

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

 *

 * Copyright (C) 2004 IVER T.I. 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

 *

 *   IVER T.I. S.A

 *   Salamanca 50

 *   46005 Valencia

 *   Spain

 *

 *   +34 963163400

 *   dac@iver.es

 */

package com.iver.gvsig.geoprocessing.operations;

import java.util.BitSet;

import java.util.Vector;

import com.vividsolutions.jts.geom.Geometry;

import com.vividsolutions.jts.geom.GeometryCollection;

import com.vividsolutions.jts.geom.GeometryFactory;

import com.vividsolutions.jts.geom.LineSegment;

import com.vividsolutions.jts.geom.LineString;

import com.vividsolutions.jts.geom.LinearRing;

/**

 * @author jmorell

 */

public final class GeoProcessingTopologyOperations {

    public static Geometry[] makeBuffers(Geometry[] geometries, double[] bufferDistances, int quadrantSegments) {

        Geometry[] buffers = new Geometry[geometries.length];

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

            Geometry geometry = geometries[i];

            buffers[i] = geometry.buffer(bufferDistances[i], quadrantSegments);

        }

        return buffers;

    }

    public static Geometry makeDissolveBuffer(Geometry[] geometries, double bufferDistance, int quadrantSegments) {

        GeometryFactory geometryFactory = new GeometryFactory();

        GeometryCollection geometryCollection = new GeometryCollection(geometries,

                geometryFactory);

        Geometry geometryCollectionBuffer = geometryCollection.buffer(bufferDistance, quadrantSegments);

        return geometryCollectionBuffer;

    }

    public static Geometry makeDissolveBuffer(Geometry[] geometries, double[] bufferDistances, int quadrantSegments) {

        Geometry[] buffers = new Geometry[geometries.length];

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

            Geometry geometry = geometries[i];

            buffers[i] = geometry.buffer(bufferDistances[i], quadrantSegments);

        }

        GeometryFactory geometryFactory = new GeometryFactory();

        GeometryCollection geometryCollection = new GeometryCollection(buffers,

                geometryFactory);

        // Hago un buffer con d=0 solo para poder devolver un POLYGON y no una GEOMETRYCOLLECTION

        // Molar?a conseguir el mismo efecto de una manera m?s ortodoxa ... investigar ...

        Geometry geometryCollectionBuffer = geometryCollection.buffer(0);

        System.out.println("geometryCollection = " + geometryCollection);

        return geometryCollectionBuffer;

    }

    /*public static Geometry[] makeDissolve(Geometry[] geometriesToDissolve, AlphanumericData lyr, String dissolveAttributeName) {

        Vector resultGeometries = new Vector(); 

        DataSource ds;

        try {

            ds = lyr.getRecordset();

            int fieldId = ds.getFieldIndexByName(dissolveAttributeName);

            Value[] fieldValues = new Value[(int)ds.getRowCount()];

            //int j = 0;

            for (int i=0;i<ds.getRowCount();i++) {

                fieldValues[i] = ds.getFieldValue(i, fieldId);

            }

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

                Value valuei = fieldValues[i];

                Geometry geometryi = geometriesToDissolve[i];

                //Geometry jtsGeometryi = geometryi.toJTSGeometry();

                for (int j=0;j<ds.getRowCount();j++) {

                    if (j!=i) {

                        Value valuej = ds.getFieldValue(j, fieldId);

                        if (((BooleanValue)(valuej.equals(valuei))).getValue()) {

                            Geometry geometryj = geometriesToDissolve[j];

                            //Geometry jtsGeometryj = geometryj.toJTSGeometry();

                            //if (jtsGeometryj.intersection(jtsGeometryi) instanceof LineString ||

                            //        jtsGeometryj.intersection(jtsGeometryi) instanceof LinearRing) {

                                geometryi = geometryj.union(geometryi);

                                //FPolygon2D union = (FPolygon2D)FConverter.jts_to_java2d(jtsUnion);

                                //resultGeometries.add(ShapeFactory.createGeometry(union));

                            //}

                        }

                    }

                }

                resultGeometries.add(geometryi);

            }

        } catch (DriverException e) {

            // TODO Auto-generated catch block

            e.printStackTrace();

        } catch (com.hardcode.gdbms.engine.data.driver.DriverException e) {

            // TODO Auto-generated catch block

            e.printStackTrace();

        } catch (IncompatibleTypesException e) {

            // TODO Auto-generated catch block

            e.printStackTrace();

        }

        Geometry[] result = new Geometry[resultGeometries.size()];

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

            result[i] = (Geometry)resultGeometries.get(i);

        }

        return result;

    }*/

    /*public static Geometry[] makeClip(Geometry[] geometriesToClip, Geometry[] clippingGeometries) {

        Vector geometriesClipped = new Vector();

                int l=0;

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

            Geometry geometryToClip = geometriesToClip[i];

            int k=0;

            for (int j=0;j<clippingGeometries.length;j++) {

                Geometry clippingGeometry = clippingGeometries[j];

                if (clippingGeometry.intersects(geometryToClip)) {

                    geometriesClipped.add(geometryToClip.intersection(clippingGeometry));

                    // Para hacer un clip y no un intersect ...

                    if (k>0) {

                        geometriesClipped.set(l, ((Geometry)geometriesClipped.get(l)).union((Geometry)geometriesClipped.get(l-1)));

                    }

                    k++;

                    l++;

                }

            }

        }

        Geometry[] result = new Geometry[geometriesClipped.size()];

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

            result[i] = (Geometry)geometriesClipped.get(i);

        }

        return result;

    }*/

    //public static Geometry[] makeIntersect(Geometry[] geometriesToIntersect, Geometry[] intersectingGeometries) {

        /*Vector jtsGeometriesIntersected = new Vector();

        IGeometry[] result = new IGeometry[geometriesToIntersect.length];

        Geometry[] jtsGeometriesToClip = new Geometry[geometriesToIntersect.length];

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

            IGeometry geometryToClip = geometriesToIntersect[i];

            jtsGeometriesToClip[i] = geometryToClip.toJTSGeometry();

        }

        Geometry[] jtsClippingGeometries = new Geometry[intersectingGeometries.length];

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

            IGeometry clippingGeometry = intersectingGeometries[i];

            jtsClippingGeometries[i] = clippingGeometry.toJTSGeometry();

        }

                Selectable selectable = (Selectable)layerToIntersect;

                FBitSet fBitSet = new FBitSet();

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

            Geometry jtsGeometryToClip = jtsGeometriesToClip[i];

            for (int j=0;j<jtsClippingGeometries.length;j++) {

                Geometry jtsClippingGeometry = jtsClippingGeometries[j];

                if (jtsClippingGeometry.intersects(jtsGeometryToClip)) {

                                fBitSet.set(i);

                    jtsGeometriesIntersected.add(jtsGeometryToClip.intersection(jtsClippingGeometry));

                }

            }

        }

                selectable.setSelection(fBitSet);

        result = new IGeometry[jtsGeometriesIntersected.size()];

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

            FShape shapeResult = (FShape)FConverter.jts_to_java2d((Geometry)jtsGeometriesIntersected.get(i));

            result[i] = ShapeFactory.createGeometry(shapeResult);

        }

        return result;*/

        /*Vector geometriesIntersected = new Vector();

        //FBitSet fBitSet = new FBitSet();

        // Convertimos a JTS

        //int l=0;

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

            Geometry geometryToIntersect = geometriesToIntersect[i];

            //int k=0;

            for (int j=0;j<intersectingGeometries.length;j++) {

                Geometry intersectingGeometry = intersectingGeometries[j];

                if (intersectingGeometry.intersects(geometryToIntersect)) {

                    //fBitSet.set(i);

                    geometriesIntersected.add(geometryToIntersect.intersection(intersectingGeometry));

                    // Para hacer un clip y no un intersect ...

                    //if (k>0) {

                    //    geometriesIntersected.set(l, ((Geometry)geometriesIntersected.get(l)).union((Geometry)geometriesIntersected.get(l-1)));

                    //}

                    //k++;

                    //l++;

                }

            }

        }

        Geometry[] result = new Geometry[geometriesIntersected.size()];

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

            result[i] = (Geometry)geometriesIntersected.get(i);

        }

        return result;

    }*/

    /*public static Geometry[] makeUnion(Geometry[] geometriesToUnion, Geometry[] uningGeometries) {

        Geometry[] result = new Geometry[geometriesToUnion.length];

        Vector geometriesUned = new Vector();

                //Selectable selectable = (Selectable)layerToUnion;

                //FBitSet fBitSet = new FBitSet();

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

            Geometry geometryToUnion = geometriesToUnion[i];

            for (int j=0;j<uningGeometries.length;j++) {

                Geometry uningGeometry = uningGeometries[j];

                if (uningGeometry.intersects(geometryToUnion)) {

                                //fBitSet.set(i);

                    geometriesUned.add(geometryToUnion.intersection(uningGeometry));

                    //geometriesUned.add(geometryToUnion.difference(uningGeometry));

                }

            }

        }

        Vector geometriesUned2 = new Vector();

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

            geometriesUned2.add(geometriesUned.get(i));

        }

        int num = geometriesUned.size();

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

            Geometry geometryToUnion = geometriesToUnion[i];

            boolean intersectsWithAnyGeometry = false;

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

                Geometry geometryUned = (Geometry)geometriesUned.get(j);

                if (geometryToUnion.intersects(geometryUned)) intersectsWithAnyGeometry = true;

            }

            if (intersectsWithAnyGeometry) {

                //Geometry difference = geometryToUnion.difference(geometryUned);

                //geometriesUned2.add(difference);

            } else {

                geometriesUned2.add(geometryToUnion);

            }

        }

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

            Geometry uningGeometry = uningGeometries[i];

            boolean intersectsWithAnyGeometry = false;

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

                Geometry geometryUned = (Geometry)geometriesUned.get(j);

                if (uningGeometry.intersects(geometryUned)) intersectsWithAnyGeometry = true;

            }

            if (intersectsWithAnyGeometry) {

                //Geometry difference = jtsUningGeometry.difference(jtsGeometryUned);

                //jtsGeometriesUned2.add(difference);

            } else {

                geometriesUned2.add(uningGeometry);

            }

        }

        System.out.println("geometriesUned2.size() = " + geometriesUned2.size());

        // Le quito los cachos que ya tengo a los features que faltan

        BitSet bitSet1 = new BitSet();

        bitSet1.clear();

        //int k1=0;

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

            Geometry geometryUned2 = (Geometry)geometriesUned2.get(i);

            for (int j=0;j<uningGeometries.length;j++) {

                System.out.println("!(uningGeometries[j].equals(geometryUned2)) = " + !(uningGeometries[j].equals(geometryUned2)));

                if (uningGeometries[j].intersects(geometryUned2) && !(uningGeometries[j].equals(geometryUned2))) {

                    uningGeometries[j] = uningGeometries[j].difference(geometryUned2);

                    //bitSet1.set(k1);

                    bitSet1.set(j);

                }

                //k1++;

            }

        }

        // Le quito los cachos que ya tengo a los features que faltan

        BitSet bitSet2 = new BitSet();

        bitSet2.clear();

        int k2=0;

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

            Geometry geometryUned2 = (Geometry)geometriesUned2.get(i);

            for (int j=0;j<geometriesToUnion.length;j++) {

                System.out.println("!(geometriesToUnion[j].equals(geometryUned2)) = " + !(geometriesToUnion[j].equals(geometryUned2)));

                if (geometriesToUnion[j].intersects(geometryUned2) && !(geometriesToUnion[j].equals(geometryUned2))) {

                    geometriesToUnion[j] = geometriesToUnion[j].difference(geometryUned2);

                    bitSet2.set(k2);

                }

                k2++;

            }

        }

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

            System.out.println("bitSet2.get(" + i + ") = " + bitSet2.get(i));

        }

        // Ahora que les he quitado los cachos que ya ten?a, le meto los features que

        // faltaban

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

            if (bitSet1.get(i)) {

                geometriesUned2.add(uningGeometries[i]);

            }

        }

        // Ahora que les he quitado los cachos que ya ten?a, le meto los features que

        // faltaban

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

            if (bitSet2.get(i)) {

                geometriesUned2.add(geometriesToUnion[i]);

            }

        }

                //selectable.setSelection(fBitSet);

        result = new Geometry[geometriesUned2.size()];

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

            result[i] = (Geometry)geometriesUned2.get(i);

        }

        return result;

    }*/

    /*public static Geometry[] makeDissolve() {

        Vector geometriesDissolved = new Vector();

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

            Geometry geometryToDissolvei = geometriesToDissolve[i];

            for (int j=0;j<geometriesToDissolve.length;j++) {

                Geometry geometryToDissolvej = geometriesToDissolve[j];

                if (i!=j && intersectingGeometry.intersects(geometryToIntersect)) {

                    geometriesIntersected.add(geometryToIntersect.intersection(intersectingGeometry));

                }

            }

        }

        Geometry[] result = new Geometry[geometriesIntersected.size()];

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

            result[i] = (Geometry)geometriesIntersected.get(i);

        }

        return result;*/

        // Conseguimos las geometr?as

        /*IGeometry[] geometries = new IGeometry[0];

        Selectable inputSelectable = (Selectable)input;

                SingleLayer inputLayer = (SingleLayer)input;

                VectorialAdapter inputLayerVectorialAdapter = inputLayer.getSource();

                try {

            geometries = new IGeometry[inputLayerVectorialAdapter.getShapeCount()];

            for (int i=0;i<inputLayerVectorialAdapter.getShapeCount();i++) {

                geometries[i] = (IGeometry)inputLayerVectorialAdapter.getShape(i);

            }

        } catch (DriverIOException e1) {

            // TODO Auto-generated catch block

            e1.printStackTrace();

        }

        // Convertimos a JTS

        Geometry[] jtsGeometries = new Geometry[geometries.length];

        System.out.println("geometries.length = " + geometries.length);

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

            IGeometry geometry = geometries[i];

            jtsGeometries[i] = geometry.toJTSGeometry();

        }

        // 

        Vector resultGeometries = new Vector(); 

                AlphanumericData lyr = (AlphanumericData)input;

                DataSource ds;

                try {

            ds = lyr.getRecordset();

            int fieldId = ds.getFieldIndexByName(fieldSelectedString);

            Value[] fieldValues = new Value[(int)ds.getRowCount()];

                    int j = 0;

            for (int i=0;i<ds.getRowCount();i++) {

                fieldValues[i] = ds.getFieldValue(i, fieldId);

            }

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

                Value valuei = fieldValues[i];

                IGeometry geometryi = geometries[i];

                Geometry jtsGeometryi = geometryi.toJTSGeometry();

                for (j=0;j<ds.getRowCount();j++) {

                    if (j!=i) {

                        Value valuej = ds.getFieldValue(j, fieldId);

                        if (((BooleanValue)(valuej.equals(valuei))).getValue()) {

                            IGeometry geometryj = geometries[j];

                            Geometry jtsGeometryj = geometryj.toJTSGeometry();

                            if (jtsGeometryj.intersection(jtsGeometryi) instanceof LineString ||

                                    jtsGeometryj.intersection(jtsGeometryi) instanceof LinearRing) {

                                Geometry jtsUnion = jtsGeometryj.union(jtsGeometryi);

                                FPolygon2D union = (FPolygon2D)FConverter.jts_to_java2d(jtsUnion);

                                resultGeometries.add(ShapeFactory.createGeometry(union));

                            }

                        }

                    }

                }

            }

        } catch (DriverException e) {

            // TODO Auto-generated catch block

            e.printStackTrace();

        } catch (com.hardcode.gdbms.engine.data.driver.DriverException e) {

            // TODO Auto-generated catch block

            e.printStackTrace();

        } catch (IncompatibleTypesException e) {

            // TODO Auto-generated catch block

            e.printStackTrace();

        }

        IGeometry[] result = new IGeometry[resultGeometries.size()];

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

            result[i] = (IGeometry)resultGeometries.get(i);

        }

        return result;*/

    //}

    /*public static IGeometry[] makeMerge(FLayer[] inputLayers, FLayer fixedLayer) {

                int geometryCount = 0;

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

                    VectorialAdapter inputLayerVectorialAdapter = ((SingleLayer)inputLayers[i]).getSource();

                    try {

                geometryCount = geometryCount + inputLayerVectorialAdapter.getShapeCount();

            } catch (DriverIOException e) {

                // TODO Auto-generated catch block

                e.printStackTrace();

            }

                }

        IGeometry[] geometries = new IGeometry[geometryCount];

        int k=0;

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

                    VectorialAdapter inputLayerVectorialAdapter = ((SingleLayer)inputLayers[i]).getSource();

                    try {

                for (int j=0;j<inputLayerVectorialAdapter.getShapeCount();j++) {

                    geometries[k] = inputLayerVectorialAdapter.getShape(j);

                    k++;

                }

            } catch (DriverIOException e) {

                // TODO Auto-generated catch block

                e.printStackTrace();

            }

                }

            return geometries;

    }*/

    /*public static IGeometry[] makeSpatialJoin(FLayer layerToSJ, FLayer SJLayer) {

            VectorialAdapter inputLayerVectorialAdapter = ((SingleLayer)layerToSJ).getSource();

        int geometryCount=0;

        IGeometry[] geometries = null;

        try {

            geometryCount = inputLayerVectorialAdapter.getShapeCount();

            geometries = new IGeometry[geometryCount];

            for (int j=0;j<inputLayerVectorialAdapter.getShapeCount();j++) {

                geometries[j] = inputLayerVectorialAdapter.getShape(j);

            }

        } catch (DriverIOException e) {

            // TODO Auto-generated catch block

            e.printStackTrace();

        }

        return geometries;

    }*/

        /*private static FPolygon2D points2DToFPolygon2D(Point2D[] pts) {

                GeneralPathX genPathX = new GeneralPathX();

                genPathX.moveTo(pts[0].getX(), pts[0].getY());

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

                        genPathX.lineTo(pts[i].getX(), pts[i].getY());

                }

                genPathX.closePath();

                return new FPolygon2D(genPathX);

        }*/

}