| gvSIG desktop 1

    /*public static void saveBufferResultsToShapeFile(IGeometry[] geometries, File file) {

    public static void saveSpatialjoinResultsToShapeFile(IGeometry[] geometries, File file) {

        SHP.SHPOnlyFromGeometries(geometries,file);

    public static void saveClipResultsToShapeFile(IGeometry[] geometries, File file) {

        SHP.SHPOnlyFromGeometries(geometries,file);

    }

    public static void saveIntersectResultsToShapeFile(IGeometry[] geometries, File file) {

        if (!(file.getPath().endsWith(".shp") || file.getPath().endsWith(".SHP"))){

            file=new File(file.getPath()+".shp");

        SHP.SHPOnlyFromGeometries(geometries,file);

    }

    public static void saveUnionResultsToShapeFile(IGeometry[] geometries, File file) {

        if (!(file.getPath().endsWith(".shp") || file.getPath().endsWith(".SHP"))){

            file=new File(file.getPath()+".shp");

        }

        SHP.SHPOnlyFromGeometries(geometries,file);

    }*/

    /*public static void saveResultsToShapeFile(IGeometry[] geometries, File file) {

        if (!(file.getPath().endsWith(".shp") || file.getPath().endsWith(".SHP"))){

            file=new File(file.getPath()+".shp");

        }

    }*/

    public static void saveResultsToShapeFile(IGeometry[] geometries, File file) {

        if (!(file.getPath().endsWith(".shp") || file.getPath().endsWith(".SHP"))){

            file=new File(file.getPath()+".shp");

        }

        SHP.SHPOnlyFromGeometries(geometries,file);

    public static void saveBufferResultsToDbaseFile(File file, AlphanumericData lyr, boolean dissolveBuffer, boolean isDbfFile) 

        if (fBitSet.cardinality()==0) fBitSet.set(0, (int)lyr.getRecordset().getRowCount());

        else saveAllFieldsAndRows(sds, fBitSet, file, isDbfFile);

    // TODO: Provisional. Hasta que Fernando le meta PKs al resto de ficheros.

    private static void saveAllFieldsAndRows(SelectableDataSource sds, FBitSet fBitSet, File file, boolean isDbfFile) 

        ds.stop();

        sds.stop();

        // Los DS que vienen de un DBF vienen con PK y los que vienen de un DXF todav?a no. Mientras esto

        // est? as?, hay que distinguir entre estos or?genes. Ahora solo se mete PK en los DBFs.

        int fieldCount = 0;

        if (isDbfFile) fieldCount = sds.getFieldCount();

        else fieldCount = sds.getFieldCount()+1;

        Value[][] values = new Value[(int)fBitSet.cardinality()][fieldCount];

        int k=0;

                for (int j=0;j<fieldCount-1;j++) {

                    values[k][j] = sds.getFieldValue(i, j);

                k++;

            values[i][fieldCount-1] = ValueFactory.createValue(i);

            //for (int j=0;j<fBitSet.cardinality();j++) {

            int k=0;

            int l=0;

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

                    values[l] = value;

                        if (!((BooleanValue)value.equals(values[j-k])).getValue()) {

                    l++;

                k++;

        dw.beginTrans();

        sds.stop();

        values.add(ValueFactory.createValue(0));

    // TODO: Provisional. Hasta que Fernando le meta PKs al resto de ficheros.

    public static void saveMergeResultsToDbaseFile(File file, AlphanumericData[] lyrs, AlphanumericData lyr, boolean isDbfFile) 

        // Los DS que vienen de un DBF vienen con PK y los que vienen de un DXF todav?a no. Mientras esto

        // est? as?, hay que distinguir entre estos or?genes. Ahora solo se mete PK en los DBFs.

        int fieldCount = 0;

        if (isDbfFile) fieldCount = sds.getFieldCount();

        else fieldCount = sds.getFieldCount()+1;

        String[] fieldNames = new String[fieldCount];

        int[] fieldTypes = new int[fieldCount];

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

        ds.stop();

        sds.stop();

        // Tener en cuenta que podemos estar trabajando con selecciones y no con capas

        // enteras.

        FBitSet[] fBitSets = new FBitSet[lyrs.length];//((Selectable)lyr).getSelection();

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

            fBitSets[i] = lyrs[i].getRecordset().getSelection();

            if (fBitSets[i].cardinality()==0) {

                fBitSets[i].set(0, (int)lyrs[i].getRecordset().getRowCount());

            }

        }

            rowNumber = rowNumber + (int)lyrs[i].getRecordset().getSelection().cardinality();

        Value[][] values = new Value[rowNumber][fieldCount];

            for (int j=0;j<fieldCount-1;j++) {

                for (int k=0;k<lyrs[i].getRecordset().getFieldCount()-1;k++) {

                            if (fBitSets[i].get(l)) {

                                values[m][j] = lyrs[i].getRecordset().getFieldValue(l, lyrs[i].getRecordset().getFieldIndexByName(fieldNames[j])); // ?fieldNames[k] o fieldNames[j]?

                                m++;

                            }

                        if (fBitSets[i].get(l)) {

                            values[m][j] = ValueFactory.createNullValue();

                            m++;

                        }

            //n=(int)lyrs[i].getRecordset().getRowCount();

            n=(int)lyrs[i].getRecordset().getSelection().cardinality();

            values[i][fieldCount-1] = ValueFactory.createValue(i);

        // Chapando todos los SDS antes de rellenar ...

        /*for (int i=0;i<lyrs.length;i++) {

            lyrs[i].getRecordset().stop();

        }*/

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

        FBitSet fBitSet = ((Selectable)lyr).getSelection();

            if (fBitSet.get(i)) {

                values.add(sds.getFieldValue(i, sds.getFieldIndexByName(dissolveAttributeName)));

            }

                if (j>i) {

                    if (((BooleanValue)((Value)values.get(i)).equals((Value)values.get(j))).getValue()) {

                        values.remove(j);

                        j--;

                    }

        ds.stop();

        sds.stop();

     * saveSpatialjoinResultsToShapeFile() method.

    /*public static void saveSpatialjoinResultsToDbaseFile(File file, AlphanumericData lyr) 

    }*/

    /**

     * Creates the .dbf result file for the clip operation. This .dbf file

     * corresponds to the .shp that have been created with the

     * saveClipResultsToShapeFile() method.

     * @param file, output file.

     * @param lyr, output theme table to write.

     * @throws DriverException

     * @throws com.hardcode.gdbms.engine.data.driver.DriverException

     * @throws IncompatibleTypesException

     * @throws DriverLoadException

     * @throws NoSuchTableException

     */

    /*public static void saveClipResultsToDbaseFile(File file, AlphanumericData lyr) 

            throws DriverException, 

            com.hardcode.gdbms.engine.data.driver.DriverException, 

            IncompatibleTypesException, DriverLoadException, NoSuchTableException {

        FBitSet fBitSet = ((Selectable)lyr).getSelection();

    }*/

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

    }*/

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

        /*Vector geometriesIntersected = new Vector();

    }*/

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

    }*/

import com.vividsolutions.jts.geom.Coordinate;

import com.vividsolutions.jts.geom.GeometryCollection;

import com.vividsolutions.jts.geom.GeometryFactory;

import com.vividsolutions.jts.geom.LineString;

import com.vividsolutions.jts.geom.MultiPoint;

import com.vividsolutions.jts.geom.Point;

import com.vividsolutions.jts.geom.Polygon;

import com.vividsolutions.jts.operation.distance.DistanceOp;

import java.io.File;

            if (jtsGeometries[i] instanceof MultiPoint) {

                double[] xcoords = new double[jtsGeometries[i].getNumGeometries()];

                double[] ycoords = new double[jtsGeometries[i].getNumGeometries()];

                for (int j=0;j<jtsGeometries[i].getNumGeometries();j++) {

                    xcoords[j] = ((Point)jtsGeometries[i].getGeometryN(j)).getX();

                    ycoords[j] = ((Point)jtsGeometries[i].getGeometryN(j)).getY();

                }

                geoms[i] = ShapeFactory.createMultipoint2D(xcoords, ycoords);

            } else {

                shapes[i] = FConverter.jts_to_java2d(jtsGeometries[i]);

                geoms[i] = ShapeFactory.createGeometry(shapes[i]);

            }

        // TODO: Provisional. Hasta que Fernando le meta PKs al resto de ficheros.

        //System.out.println("bufferingLayerName = " + bufferingLayerName);

        boolean isDbfFile = false;

        if (bufferingLayerName.endsWith(".shp") || bufferingLayerName.endsWith(".SHP")) isDbfFile = true;

            //dissolveBuffer = true;

                dissolveBuffer = true;

            //dissolveBuffer = false;

                dissolveBuffer = true;

        GeoProcessingPersistenceOperations.saveResultsToShapeFile(shapes, geoProcessingBufferPanel.getOutputFile());

            // TODO: Provisional. Hasta que Fernando le meta PKs al resto de ficheros.

            GeoProcessingTableOperations.saveBufferResultsToDbaseFile(geoProcessingBufferPanel.getOutputFile(), lyr, dissolveBuffer, isDbfFile);

        // TODO: Provisional. Hasta que Fernando le meta PKs al resto de ficheros.

        boolean isDbfFile = false;

        if (fieldsFromLayerName.endsWith(".shp") || fieldsFromLayerName.endsWith(".SHP")) isDbfFile = true;

        boolean[] selecteds = new boolean[layersToMerge.length];

            if (!((Selectable)layersToMerge[i]).getSelection().isEmpty()) selecteds[i] = true;

            Geometry[] geometriesToMerge = getJtsGeometries(layersToMerge[i], selecteds[i]);

        GeoProcessingPersistenceOperations.saveResultsToShapeFile(shapes, geoProcessingMergePanel.getOutputFile());

            GeoProcessingTableOperations.saveMergeResultsToDbaseFile(geoProcessingMergePanel.getOutputFile(), lyrs, lyr, isDbfFile);

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

                lyrs[i].getRecordset().getSelection().clear();

            }

        if (((JCheckBox)geoProcessingDissolvePanel.getComponent(3)).isSelected()) selected = true;

        SelectableDataSource sds;

            sds = lyr.getRecordset();

            FBitSet fBitSet = sds.getSelection();

            if (fBitSet.cardinality()==0) fBitSet.set(0, (int)lyr.getRecordset().getRowCount());

            Value[] fieldValues = new Value[sds.getSelection().cardinality()];

            int k=0;

                if (fBitSet.get(i)) {

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

                    k++;

                }

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

                        Value valuej = fieldValues[j];

                    if (j>i) {

                        if (((Geometry)resultGeometries.get(i)).equals((Geometry)resultGeometries.get(j))) {

                            resultGeometries.remove(j);

                            j--;

                        }

        GeoProcessingPersistenceOperations.saveResultsToShapeFile(shapes, geoProcessingDissolvePanel.getOutputFile());

        try {

            GeoProcessingTableOperations.saveDissolveResultsToDbaseFile(geoProcessingDissolvePanel.getOutputFile(), lyr, dissolveAttributeName);

            lyr.getRecordset().getSelection().clear();

        }

    private void spatialjoinMethod() {

        String layerToJoinName = (String)((JComboBox)geoProcessingSpatialjoinPanel.getComponent(0)).getSelectedItem();

        FLayer layerToJoin = layers.getLayer(layerToJoinName);

        String joiningLayerName = (String)((JComboBox)geoProcessingSpatialjoinPanel.getComponent(3)).getSelectedItem();

        FLayer joiningLayer = layers.getLayer(joiningLayerName);

        boolean selected = false;

        try {

            if (((JCheckBox)geoProcessingSpatialjoinPanel.getComponent(1)).isSelected()) selected = true;

            Geometry[] geometriesToJoin = getJtsGeometries(layerToJoin, selected);

            AlphanumericData lyrToJoin = (AlphanumericData)layerToJoin;

            SelectableDataSource lyrToJoinSDS = lyrToJoin.getRecordset();

            FBitSet bitsetToJoin = lyrToJoinSDS.getSelection();

            if (bitsetToJoin.cardinality()==0) bitsetToJoin.set(0, (int)lyrToJoin.getRecordset().getRowCount());

            if (((JCheckBox)geoProcessingSpatialjoinPanel.getComponent(5)).isSelected()) selected = true;

            Geometry[] joiningGeometries = getJtsGeometries(joiningLayer, selected);

            AlphanumericData joiningLyr = (AlphanumericData)joiningLayer;

            SelectableDataSource joiningLyrSDS = joiningLyr.getRecordset();

            FBitSet joiningBitset = joiningLyrSDS.getSelection();

            if (joiningBitset.cardinality()==0) joiningBitset.set(0, (int)joiningLyr.getRecordset().getRowCount());

            DataSource lyrToJoinDS;

            DataSource joiningLyrDS;

            lyrToJoinDS = lyrToJoin.getRecordset();

            joiningLyrDS = joiningLyr.getRecordset();

            // Los campos se a?aden siempre. Los valores solo cuando toca ...

            String[] lyrToJoinFieldNames = new String[lyrToJoinDS.getFieldCount()];

            int[] lyrToJoinFieldTypes = new int[lyrToJoinDS.getFieldCount()];

            for (int i = 0; i < lyrToJoinDS.getFieldCount(); i++) {

                lyrToJoinFieldNames[i] = lyrToJoinDS.getFieldName(i);

                lyrToJoinFieldTypes[i] = lyrToJoinDS.getFieldType(i);

            }

            String[] joiningLyrFieldNames = new String[joiningLyrDS.getFieldCount()];

            int[] joiningLyrFieldTypes = new int[joiningLyrDS.getFieldCount()];

            for (int i = 0; i < joiningLyrDS.getFieldCount(); i++) {

                joiningLyrFieldNames[i] = joiningLyrDS.getFieldName(i);

                joiningLyrFieldTypes[i] = joiningLyrDS.getFieldType(i);

            }

            String[] joinedLyrFieldNames = new String[lyrToJoinDS.getFieldCount()+joiningLyrDS.getFieldCount()-2]; // Le quito los dos PKs

            int[] joinedLyrFieldTypes = new int[lyrToJoinDS.getFieldCount()+joiningLyrDS.getFieldCount()-2];

            int l=0;

            for (int i=0;i<lyrToJoinFieldNames.length-1;i++) {

                joinedLyrFieldNames[i] = lyrToJoinFieldNames[i];

                joinedLyrFieldTypes[i] = lyrToJoinFieldTypes[i];

                l++;

            }

            for (int i=0;i<joiningLyrFieldNames.length-1;i++) {

                joinedLyrFieldNames[i+l] = joiningLyrFieldNames[i];

                joinedLyrFieldTypes[i+l] = joiningLyrFieldTypes[i];

            }

            DataSourceFactory dsf = lyrToJoinSDS.getDataSourceFactory();

            File file = geoProcessingSpatialjoinPanel.getOutputFile();

            dsf.createFileDataSource("gdbms dbf driver", "new_table", file.getAbsolutePath().replaceAll(".shp", ".dbf"), joinedLyrFieldNames, joinedLyrFieldTypes);

            DataSource ds = dsf.createRandomDataSource("new_table");

            ds.start();

            DataWare dw = ds.getDataWare(DataSourceFactory.MANUAL_OPENING);

            dw.beginTrans();

            ds.stop();

            lyrToJoinDS.stop();

            joiningLyrDS.stop();

            lyrToJoinSDS.stop();

            joiningLyrSDS.stop();

            // Recorrer las geometr?as buscando las que intersectan. No porque

            // por ejemplo los puntos no intersectan ...

            // Ver de que combinaci?n se trata y calcular nearest, part of o inside

            // seg?n corresponda.

            // Si intersecta copiarle los atributos. O sea rellenar Values como

            // toque ...

            Value[][] values = new Value[geometriesToJoin.length][joinedLyrFieldNames.length+1]; // +1 porque faltaba el PK

            // Movida para el nearest entre puntos

            //Point[] joiningPoints = new Point[joiningGeometries.length];

            Geometry[] joiningGeometrySet = new Geometry[joiningGeometries.length];

            /*for (int i=0;i<joiningGeometries.length;i++) {

                joiningPoints[i] = (Point)joiningGeometries[i];

            }*/

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

                joiningGeometrySet[i] = (Geometry)joiningGeometries[i];

            }

            //MultiPoint joiningMultiPoint = new MultiPoint(joiningPoints, new GeometryFactory());

            GeometryCollection joiningGeometryCollection = new GeometryCollection(joiningGeometrySet, new GeometryFactory());

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

                Geometry geometryToJoin = geometriesToJoin[i];

                // Movida para el nearest entre puntos

                //Coordinate[] coords = DistanceOp.closestPoints(geometryToJoin, joiningMultiPoint);

                Coordinate[] coords = DistanceOp.closestPoints(geometryToJoin, joiningGeometryCollection);

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

                    Geometry joiningGeometry = joiningGeometries[j];

                    if (geometryToJoin instanceof Point && joiningGeometry instanceof Point) {

                        // Rellenar el PK. Lo tengo que hacer antes del break

                        values[i][joinedLyrFieldNames.length] = ValueFactory.createValue(i);

                        for (int k=0;k<lyrToJoinFieldNames.length-1;k++) {

                            values[i][k] = lyrToJoinDS.getFieldValue(i, k);

                        }

                        if (coords[1].equals2D(joiningGeometry.getCoordinate())) {

                            for (int k=0;k<joiningLyrFieldNames.length-1;k++) {

                                values[i][k+l] = joiningLyrDS.getFieldValue(j, k);

                            }

                            break; // En el momento encontremos un pol?gono que contiene a otro le metemos los valores y nos vamos

                        } else {

                            for (int k=0;k<joiningLyrFieldNames.length-1;k++) {

                                values[i][k+l] = ValueFactory.createNullValue();

                            }

                        }

                    } else if (geometryToJoin instanceof Point && joiningGeometry instanceof LineString) {

                        // part of not supported yet

                    } else if (geometryToJoin instanceof Point && joiningGeometry instanceof Polygon) {

                        // Rellenar el PK. Lo tengo que hacer antes del break

                        values[i][joinedLyrFieldNames.length] = ValueFactory.createValue(i);

                        for (int k=0;k<lyrToJoinFieldNames.length-1;k++) {

                            values[i][k] = lyrToJoinDS.getFieldValue(i, k);

                        }

                        if (joiningGeometry.contains(geometryToJoin)) {

                            for (int k=0;k<joiningLyrFieldNames.length-1;k++) {

                                System.out.println(i);

                                values[i][k+l] = joiningLyrDS.getFieldValue(j, k);

                            }

                            break; // En el momento encontremos un pol?gono que contiene a otro le metemos los valores y nos vamos

                        } else {

                            for (int k=0;k<joiningLyrFieldNames.length-1;k++) {

                                values[i][k+l] = ValueFactory.createNullValue();

                            }

                        }

                    } else if (geometryToJoin instanceof LineString && joiningGeometry instanceof Point) {

                        // Rellenar el PK. Lo tengo que hacer antes del break

                        values[i][joinedLyrFieldNames.length] = ValueFactory.createValue(i);

                        for (int k=0;k<lyrToJoinFieldNames.length-1;k++) {

                            values[i][k] = lyrToJoinDS.getFieldValue(i, k);

                        }

                        if (coords[1].equals2D(joiningGeometry.getCoordinate())) {

                            for (int k=0;k<joiningLyrFieldNames.length-1;k++) {

                                values[i][k+l] = joiningLyrDS.getFieldValue(j, k);

                            }

                            break; // En el momento encontremos un pol?gono que contiene a otro le metemos los valores y nos vamos

                        } else {

                            for (int k=0;k<joiningLyrFieldNames.length-1;k++) {

                                values[i][k+l] = ValueFactory.createNullValue();

                            }

                        }

                    } else if (geometryToJoin instanceof LineString && joiningGeometry instanceof LineString) {

                        // Rellenar el PK. Lo tengo que hacer antes del break

                        values[i][joinedLyrFieldNames.length] = ValueFactory.createValue(i);

                        for (int k=0;k<lyrToJoinFieldNames.length-1;k++) {

                            values[i][k] = lyrToJoinDS.getFieldValue(i, k);

                        }

                        //if (coords[1].equals2D(joiningGeometry.getCoordinate())) {

                        if (joiningGeometry.contains(geometryToJoin) || geometryToJoin.contains(joiningGeometry)) {

                            for (int k=0;k<joiningLyrFieldNames.length-1;k++) {

                                values[i][k+l] = joiningLyrDS.getFieldValue(j, k);

                            }

                            break; // En el momento encontremos un pol?gono que contiene a otro le metemos los valores y nos vamos

                        } else {

                            for (int k=0;k<joiningLyrFieldNames.length-1;k++) {

                                values[i][k+l] = ValueFactory.createNullValue();

                            }

                        }

                    } else if (geometryToJoin instanceof LineString && joiningGeometry instanceof Polygon) {

                        // Rellenar el PK. Lo tengo que hacer antes del break

                        values[i][joinedLyrFieldNames.length] = ValueFactory.createValue(i);

                        for (int k=0;k<lyrToJoinFieldNames.length-1;k++) {

                            values[i][k] = lyrToJoinDS.getFieldValue(i, k);

                        }

                        if (joiningGeometry.contains(geometryToJoin)) {

                            for (int k=0;k<joiningLyrFieldNames.length-1;k++) {

                                values[i][k+l] = joiningLyrDS.getFieldValue(j, k);

                            }

                            break; // En el momento encontremos un pol?gono que contiene a otro le metemos los valores y nos vamos

                        } else {

                            for (int k=0;k<joiningLyrFieldNames.length-1;k++) {

                                values[i][k+l] = ValueFactory.createNullValue();

                            }

                        }

                    } else if (geometryToJoin instanceof Polygon && joiningGeometry instanceof Point) {

                        // nearest not supported yet

                    } else if (geometryToJoin instanceof Polygon && joiningGeometry instanceof LineString) {

                        // nearest not supported yet

                    } else if (geometryToJoin instanceof Polygon && joiningGeometry instanceof Polygon) {

                        // Rellenar el PK. Lo tengo que hacer antes del break

                        values[i][joinedLyrFieldNames.length] = ValueFactory.createValue(i);

                        for (int k=0;k<lyrToJoinFieldNames.length-1;k++) {

                            values[i][k] = lyrToJoinDS.getFieldValue(i, k);

                        }

                        if (joiningGeometry.contains(geometryToJoin)) {

                            for (int k=0;k<joiningLyrFieldNames.length-1;k++) {

                                values[i][k+l] = joiningLyrDS.getFieldValue(j, k);

                            }

                            break; // En el momento encontremos un pol?gono que contiene a otro le metemos los valores y nos vamos

                        } else {

                            for (int k=0;k<joiningLyrFieldNames.length-1;k++) {

                                values[i][k+l] = ValueFactory.createNullValue();

                            }

                        }

                    } else {

                        // MultiPoint, LineSegment, LinearRing, MultiLineString, MultiPolygon faltan

                        // por implementar ...

                    }

                }

            }

            for (int i=0;i<lyrToJoinSDS.getSelection().cardinality();i++) {

                dw.insertFilledRow(values[i]);

            }

            /*for (int i=0;i<lyrToJoinDS.getRowCount();i++) {

                dw.insertFilledRow(values[i]);

            }*/

            dw.commitTrans();

            IGeometry[] shapes = getFmapGeometries(geometriesToJoin);

            // Guardo la tabla mediante gdbms. Guardo tambi?n las entidades JTS mediante gvSIG o usando solo gdbms (probablemente bastar? con usar gdbms)

            // Guardar las viejas geometr?as.

            GeoProcessingPersistenceOperations.saveResultsToShapeFile(shapes, geoProcessingSpatialjoinPanel.getOutputFile());

            //lyrToJoinSDS.getSelection().clear();

            //joiningLyrSDS.getSelection().clear();

            lyrToJoinSDS.setSelection(new FBitSet());

            joiningLyrSDS.setSelection(new FBitSet());

        } 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 (DriverLoadException e) {

            // TODO Auto-generated catch block

            e.printStackTrace();

        } catch (NoSuchTableException e) {

            // TODO Auto-generated catch block

            e.printStackTrace();

        }

    }

    // clip: intersect + dissolve

        //if (((JCheckBox)geoProcessingClipPanel.getComponent(1)).isSelected()) selected = true;

        //if (((JCheckBox)geoProcessingClipPanel.getComponent(5)).isSelected()) selected = true;

        AlphanumericData lyr = (AlphanumericData)layerToClip;

        SelectableDataSource sds;

        try {

            DataSource ds;

            ds = lyr.getRecordset();

            sds = lyr.getRecordset();

            // Tener en cuenta que podemos estar trabajando solo con una selecci?n

            //FBitSet fBitSet = ((Selectable)lyr).getSelection();

            String[] fieldNames = new String[sds.getFieldCount()-1];

            int[] fieldTypes = new int[sds.getFieldCount()-1];

            for (int i = 0; i < sds.getFieldCount()-1; i++) {

                fieldNames[i] = sds.getFieldName(i);

                fieldTypes[i] = sds.getFieldType(i);

            }

            DataSourceFactory dsf = sds.getDataSourceFactory();

            File file = geoProcessingClipPanel.getOutputFile();

            dsf.createFileDataSource("gdbms dbf driver", "new_table", file.getAbsolutePath().replaceAll(".shp", ".dbf"), fieldNames, fieldTypes);

            DataSource dataSource = dsf.createRandomDataSource("new_table");

            dataSource.start();

            DataWare dw = dataSource.getDataWare(DataSourceFactory.MANUAL_OPENING);

            dw.beginTrans();

            Vector values = new Vector();

            Vector geometriesClipped = new Vector();

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

                Geometry geometryToClip = geometriesToClip[i];

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

                    Geometry clippingGeometry = clippingGeometries[j];

                    if (clippingGeometry.intersects(geometryToClip)) {

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

                        Value[] rows = new Value[fieldNames.length+1]; // +1 porque faltaba el PK

                        for (int m=0;m<fieldNames.length;m++) {

                            rows[m] = ds.getFieldValue(i, m);

                        }

                        rows[fieldNames.length] = ValueFactory.createValue(i);

                        values.add(rows);

                    }

                }

            }

            // 

            Vector resultGeometries = new Vector();

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

                Value[] rowi = ((Value[])values.get(i));

                Geometry geometryi = ((Geometry)geometriesClipped.get(i));

                for (int j=0;j<values.size();j++) {

                    if (j>i) {

                        Value[] rowj = ((Value[])values.get(j));

                        boolean areTheSameElement = true;

                        for (int k=0;k<rowj.length;k++) {

                            //Value valuei = ds.getFieldValue(i, k);

                            //Value valuej = ds.getFieldValue(j, k);

                            Value valuei = rowi[k];

                            Value valuej = rowj[k];

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

                                areTheSameElement = false;

                            }

                        }

                        if (areTheSameElement) {

                            Geometry geometryj = ((Geometry)geometriesClipped.get(j));

                            geometryi = geometryj.union(geometryi);

                            //values.remove(j); // igual esto peta ...

                        }

                    }

                }

                resultGeometries.add(geometryi);

            }

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

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

                    if (j>i) {

                        if (((Geometry)resultGeometries.get(i)).intersects((Geometry)resultGeometries.get(j))) resultGeometries.remove(j);

                    }

                }

            }

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

                Value[] rowi = ((Value[])values.get(i));

                for (int j=0;j<values.size();j++) {

                    if (j!=i) {

                        Value[] rowj = ((Value[])values.get(j));

                        boolean areTheSameElement = true;

                        for (int k=0;k<rowj.length;k++) {

                            //Value valuei = ds.getFieldValue(i, k);

                            //Value valuej = ds.getFieldValue(j, k);

                            Value valuei = rowi[k];

                            Value valuej = rowj[k];

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

                                areTheSameElement = false;

                            }

                        }

                        if (areTheSameElement) {

                            values.remove(j);

                        }

                    }

                }

            }

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

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

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

            }

            IGeometry[] shapes = getFmapGeometries(dissolvedGeometries);

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

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

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

            }

            GeoProcessingPersistenceOperations.saveResultsToShapeFile(shapes, geoProcessingClipPanel.getOutputFile());

            dataSource.stop();

            sds.stop();

            ds.stop();

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

                dw.insertFilledRow(((Value[])values.get(i)));

            }

            dw.commitTrans();

        } 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 (DriverLoadException e) {

            // TODO Auto-generated catch block

            e.printStackTrace();

        } catch (NoSuchTableException e) {

            // TODO Auto-generated catch block

            e.printStackTrace();

        } catch (IncompatibleTypesException e) {

            // TODO Auto-generated catch block

            e.printStackTrace();

        }

    // Spatial join con Intersect

        String intersectingLayerName = (String)((JComboBox)geoProcessingIntersectPanel.getComponent(3)).getSelectedItem();

        FLayer intersectingLayer = layers.getLayer(intersectingLayerName);

        try {

            //if (((JCheckBox)geoProcessingIntersectPanel.getComponent(1)).isSelected()) selected = true;

            AlphanumericData lyrToIntersect = (AlphanumericData)layerToIntersect;

            SelectableDataSource lyrToIntersectSDS = lyrToIntersect.getRecordset();

            //if (((JCheckBox)geoProcessingIntersectPanel.getComponent(5)).isSelected()) selected = true;

            AlphanumericData intersectingLyr = (AlphanumericData)intersectingLayer;

            DataSource lyrToIntersectDS;

            DataSource intersectingLyrDS;

            lyrToIntersectDS = lyrToIntersect.getRecordset();

            intersectingLyrDS = intersectingLyr.getRecordset();

            // Los campos se a?aden siempre. Los valores solo cuando toca ...

            String[] lyrToIntersectFieldNames = new String[lyrToIntersectDS.getFieldCount()];

            int[] lyrToIntersectFieldTypes = new int[lyrToIntersectDS.getFieldCount()];

            for (int i = 0; i < lyrToIntersectDS.getFieldCount(); i++) {

                lyrToIntersectFieldNames[i] = lyrToIntersectDS.getFieldName(i);

                lyrToIntersectFieldTypes[i] = lyrToIntersectDS.getFieldType(i);

            }

            String[] intersectingLyrFieldNames = new String[intersectingLyrDS.getFieldCount()];

            int[] intersectingLyrFieldTypes = new int[intersectingLyrDS.getFieldCount()];

            for (int i = 0; i < intersectingLyrDS.getFieldCount(); i++) {

                intersectingLyrFieldNames[i] = intersectingLyrDS.getFieldName(i);

                intersectingLyrFieldTypes[i] = intersectingLyrDS.getFieldType(i);

            }

            String[] intersectedLyrFieldNames = new String[lyrToIntersectDS.getFieldCount()+intersectingLyrDS.getFieldCount()-2]; // Le quito los dos PKs

            int[] intersectedLyrFieldTypes = new int[lyrToIntersectDS.getFieldCount()+intersectingLyrDS.getFieldCount()-2];

            int l=0;

            for (int i=0;i<lyrToIntersectFieldNames.length-1;i++) {

                intersectedLyrFieldNames[i] = lyrToIntersectFieldNames[i];

                intersectedLyrFieldTypes[i] = lyrToIntersectFieldTypes[i];

                l++;

            }

            for (int i=0;i<intersectingLyrFieldNames.length-1;i++) {

                intersectedLyrFieldNames[i+l] = intersectingLyrFieldNames[i];

                intersectedLyrFieldTypes[i+l] = intersectingLyrFieldTypes[i];

            }

            DataSourceFactory dsf = lyrToIntersectSDS.getDataSourceFactory();

            File file = geoProcessingIntersectPanel.getOutputFile();

            dsf.createFileDataSource("gdbms dbf driver", "new_table", file.getAbsolutePath().replaceAll(".shp", ".dbf"), intersectedLyrFieldNames, intersectedLyrFieldTypes);

            DataSource ds = dsf.createRandomDataSource("new_table");

            ds.start();

            DataWare dw = ds.getDataWare(DataSourceFactory.MANUAL_OPENING);

            dw.beginTrans();

            ds.stop();

            // Si cierro no tendr? problemas a continuaci?n?

            lyrToIntersectSDS.stop();

            Vector values = new Vector();

            Vector geometriesIntersected = new Vector();

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

                Geometry geometryToIntersect = geometriesToIntersect[i];

                String geometryToIntersectType = geometryToIntersect.getGeometryType();

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

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

                    Geometry intersectingGeometry = intersectingGeometries[j];

                    if (intersectingGeometry.intersects(geometryToIntersect)) {

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

                        /*for (int m=0;m<intersectedLyrFieldNames.length;m++) {

                            rows[m] = ds.getFieldValue(i, m);

                        }*/

                        Value[] rows = new Value[intersectedLyrFieldNames.length+1]; // +1 porque faltaba el PK

                        for (int k=0;k<lyrToIntersectFieldNames.length-1;k++) {

                            rows[k] = lyrToIntersectDS.getFieldValue(i, k);

                        }

                        for (int k=0;k<intersectingLyrFieldNames.length-1;k++) {

                            rows[k+l] = intersectingLyrDS.getFieldValue(j, k);

                        }

                        rows[intersectedLyrFieldNames.length] = ValueFactory.createValue(i);

                        values.add(rows);

                    }

                }

            }

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

                dw.insertFilledRow(((Value[])values.get(i)));

            }

            dw.commitTrans();

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

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

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

            }

            IGeometry[] shapes = getFmapGeometries(geometriesIntersectedArray);

            // Guardo la tabla mediante gdbms. Guardo tambi?n las entidades JTS mediante gvSIG o usando solo gdbms (probablemente bastar? con usar gdbms)

            // Guardar las viejas geometr?as.

            GeoProcessingPersistenceOperations.saveResultsToShapeFile(shapes, geoProcessingIntersectPanel.getOutputFile());

        } 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 (DriverLoadException e) {

            // TODO Auto-generated catch block

            e.printStackTrace();

        } catch (NoSuchTableException e) {

            // TODO Auto-generated catch block

            e.printStackTrace();

        }

        //if (((JCheckBox)geoProcessingUnionPanel.getComponent(1)).isSelected()) selected = true;

        //if (((JCheckBox)geoProcessingUnionPanel.getComponent(5)).isSelected()) selected = true;

        //if (((JCheckBox)geoProcessingIntersectPanel.getComponent(1)).isSelected()) selected = true;

        AlphanumericData lyrToUnion = (AlphanumericData)layerToUnion;

        SelectableDataSource lyrToUnionSDS;

        try {

            lyrToUnionSDS = lyrToUnion.getRecordset();

            //if (((JCheckBox)geoProcessingIntersectPanel.getComponent(5)).isSelected()) selected = true;

            AlphanumericData uningLyr = (AlphanumericData)uningLayer;

            DataSource lyrToUnionDS;

            DataSource uningLyrDS;

            lyrToUnionDS = lyrToUnion.getRecordset();

            uningLyrDS = uningLyr.getRecordset();

            // Los campos se a?aden siempre. Los valores solo cuando toca ...

            String[] lyrToUnionFieldNames = new String[lyrToUnionDS.getFieldCount()];

            int[] lyrToUnionFieldTypes = new int[lyrToUnionDS.getFieldCount()];

            for (int i = 0; i < lyrToUnionDS.getFieldCount(); i++) {

                lyrToUnionFieldNames[i] = lyrToUnionDS.getFieldName(i);

                lyrToUnionFieldTypes[i] = lyrToUnionDS.getFieldType(i);

            }

            String[] uningLyrFieldNames = new String[uningLyrDS.getFieldCount()];

            int[] uningLyrFieldTypes = new int[uningLyrDS.getFieldCount()];

            for (int i = 0; i < uningLyrDS.getFieldCount(); i++) {

                uningLyrFieldNames[i] = uningLyrDS.getFieldName(i);

                uningLyrFieldTypes[i] = uningLyrDS.getFieldType(i);

            }

            String[] unedLyrFieldNames = new String[lyrToUnionDS.getFieldCount()+uningLyrDS.getFieldCount()-2]; // Le quito los dos PKs

            int[] unedLyrFieldTypes = new int[lyrToUnionDS.getFieldCount()+uningLyrDS.getFieldCount()-2];

            int l=0;

            for (int i=0;i<lyrToUnionFieldNames.length-1;i++) {

                unedLyrFieldNames[i] = lyrToUnionFieldNames[i];

                unedLyrFieldTypes[i] = lyrToUnionFieldTypes[i];

                l++;

            }

            for (int i=0;i<uningLyrFieldNames.length-1;i++) {

                unedLyrFieldNames[i+l] = uningLyrFieldNames[i];

                unedLyrFieldTypes[i+l] = uningLyrFieldTypes[i];

            }

            DataSourceFactory dsf = lyrToUnionSDS.getDataSourceFactory();

            File file = geoProcessingUnionPanel.getOutputFile();

            dsf.createFileDataSource("gdbms dbf driver", "new_table", file.getAbsolutePath().replaceAll(".shp", ".dbf"), unedLyrFieldNames, unedLyrFieldTypes);

            DataSource ds = dsf.createRandomDataSource("new_table");

            ds.start();

            DataWare dw = ds.getDataWare(DataSourceFactory.MANUAL_OPENING);

            dw.beginTrans();

            ds.stop();

            lyrToUnionSDS.stop();

            Vector values = new Vector();

            //Geometry[] unedGeometries = GeoProcessingTopologyOperations.makeUnion(geometriesToUnion, uningGeometries);

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

            Vector geometriesUned = new Vector();

            //Selectable selectable = (Selectable)layerToUnion;

            //FBitSet fBitSet = new FBitSet();

            // Metememos en geometriesUned las intersecciones.

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

                        Value[] intersectRow = new Value[unedLyrFieldNames.length+1];

                        for (int k=0;k<lyrToUnionFieldNames.length-1;k++) {

                            intersectRow[k] = lyrToUnionDS.getFieldValue(i, k);

                        }

                        for (int k=0;k<uningLyrFieldNames.length-1;k++) {

                            intersectRow[k+l] = uningLyrDS.getFieldValue(j, k);

                        }

                        intersectRow[unedLyrFieldNames.length] = ValueFactory.createValue(i);

                        values.add(intersectRow);

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

                    }

                }

            }

            // Rellenamos geometriesUned2 con estas intersecciones.

            Vector geometriesUned2 = new Vector();

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

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

            }

            //int num = geometriesUned.size();

            // A?ado a geometriesUned2 las geometr?as de geometriesToUnion que no

            // intersectan con uningGeometries.

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

                Geometry geometryToUnion = geometriesToUnion[i];

                boolean intersectsWithAnyGeometry = false;

                for (int j=0;j<geometriesUned.size();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);

                    Value[] unionRow = new Value[unedLyrFieldNames.length+1];

                    for (int k=0;k<lyrToUnionFieldNames.length-1;k++) {

                        unionRow[k] = lyrToUnionDS.getFieldValue(i, k);

                    }

                    for (int k=0;k<uningLyrFieldNames.length-1;k++) {

                        unionRow[k+l] = ValueFactory.createNullValue();

                    }

                    unionRow[unedLyrFieldNames.length] = ValueFactory.createValue(i);

                    values.add(unionRow);

                }

            }

            // A?ado a geometriesUned2 las geometr?as de uningGeometries que no

            // intersectan con geometriesToUnion.

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

                Geometry uningGeometry = uningGeometries[i];

                boolean intersectsWithAnyGeometry = false;

                for (int j=0;j<geometriesUned.size();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);

                    Value[] uningRow = new Value[unedLyrFieldNames.length+1];

                    for (int k=0;k<lyrToUnionFieldNames.length-1;k++) {

                        uningRow[k] = ValueFactory.createNullValue();

                    }

                    for (int k=0;k<uningLyrFieldNames.length-1;k++) {

                        uningRow[k+l] = uningLyrDS.getFieldValue(i, k);

                    }

                    uningRow[unedLyrFieldNames.length] = ValueFactory.createValue(i);

                    values.add(uningRow);

                }

            }

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

            // Le quito los cachos que ya tengo a las geometrias que faltan de

            // uningGeometries.

            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 las geometrias que faltan de

            // geometriesToUnion.

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

                        //bitSet2.set(j);

                    }

                    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 de uningGeometries

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

                if (bitSet1.get(i)) {

                    geometriesUned2.add(uningGeometries[i]);

                    Value[] uningRow = new Value[unedLyrFieldNames.length+1];

                    for (int k=0;k<lyrToUnionFieldNames.length-1;k++) {

                        uningRow[k] = ValueFactory.createNullValue();

                    }

                    for (int k=0;k<uningLyrFieldNames.length-1;k++) {

                        uningRow[k+l] = uningLyrDS.getFieldValue(i, k);

                    }

                    uningRow[unedLyrFieldNames.length] = ValueFactory.createValue(i);

                    values.add(uningRow);

                }

            }

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

            // faltaban de geometriesToUnion

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

                if (bitSet2.get(i)) {

                    geometriesUned2.add(geometriesToUnion[i]);

                    Value[] unionRow = new Value[unedLyrFieldNames.length+1];

                    for (int k=0;k<lyrToUnionFieldNames.length-1;k++) {

                        unionRow[k] = lyrToUnionDS.getFieldValue(i, k);

                    }

                    for (int k=0;k<uningLyrFieldNames.length-1;k++) {

                        unionRow[k+l] = ValueFactory.createNullValue();

                    }

                    unionRow[unedLyrFieldNames.length] = ValueFactory.createValue(i);

                    values.add(unionRow);

                }

            }

            //selectable.setSelection(fBitSet);

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

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

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

            }

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

                dw.insertFilledRow(((Value[])values.get(i)));

            }

            dw.commitTrans();

            IGeometry[] shapes = getFmapGeometries(result);

            // Guardo la tabla mediante gdbms. Guardo tambi?n las entidades JTS mediante gvSIG o usando solo gdbms (probablemente bastar? con usar gdbms)

            GeoProcessingPersistenceOperations.saveResultsToShapeFile(shapes, geoProcessingUnionPanel.getOutputFile());

        } 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 (DriverLoadException e) {

            // TODO Auto-generated catch block

            e.printStackTrace();

        } catch (NoSuchTableException e) {

            // TODO Auto-generated catch block

            e.printStackTrace();

        }

            if (fBitSet.cardinality()==0) {

                fBitSet.set(0, (int)lyr.getRecordset().getRowCount());

            }