Revision 3021

View differences:

trunk/extensions/extGeoProcessing/src/com/iver/gvsig/geoprocessing/gui/GeoProcessingPanel.java
1364 1364
            //int num = geometriesUned.size();
1365 1365
            // A?ado a geometriesUned2 las geometr?as de geometriesToUnion que no
1366 1366
            // intersectan con uningGeometries.
1367
            // los arrays originales han cambiado en los pasos anteriores?
1368
            // debuggear con el inverso a ver que pasa ...
1369
            // ?el intersect funciona como creo que funciona?
1367 1370
            for (int i=0;i<geometriesToUnion.length;i++) {
1368 1371
                Geometry geometryToUnion = geometriesToUnion[i];
1369 1372
                boolean intersectsWithAnyGeometry = false;
......
1412 1415
                    values.add(uningRow);
1413 1416
                }
1414 1417
            }
1415
            //System.out.println("geometriesUned2.size() = " + geometriesUned2.size());
1416 1418
            // Le quito los cachos que ya tengo a las geometrias que faltan de
1417
            // uningGeometries.
1419
            // geometriesToUnion.
1420
            // Esto de las kas es una irregularidad ... ver que pasa ...
1421
            // ?y si uso geometriesUned en vez del 2?
1422
            // y la k creo que deber?a estar dentro ...
1418 1423
            BitSet bitSet1 = new BitSet();
1419 1424
            bitSet1.clear();
1420 1425
            //int k1=0;
1421
            for (int i=0;i<geometriesUned2.size();i++) {
1422
                Geometry geometryUned2 = (Geometry)geometriesUned2.get(i);
1423
                for (int j=0;j<uningGeometries.length;j++) {
1424
                    //System.out.println("!(uningGeometries[j].equals(geometryUned2)) = " + !(uningGeometries[j].equals(geometryUned2)));
1425
                    if (uningGeometries[j].intersects(geometryUned2) && !(uningGeometries[j].equals(geometryUned2))) {
1426
                        uningGeometries[j] = uningGeometries[j].difference(geometryUned2);
1426
            for (int i=0;i<geometriesUned.size();i++) {
1427
                Geometry geometryUned = (Geometry)geometriesUned.get(i);
1428
                for (int j=0;j<geometriesToUnion.length;j++) {
1429
                    if (geometriesToUnion[j].intersects(geometryUned) && !(geometriesToUnion[j].equals(geometryUned))) {
1430
                        geometriesToUnion[j] = geometriesToUnion[j].difference(geometryUned);
1427 1431
                        //bitSet1.set(k1);
1428 1432
                        bitSet1.set(j);
1433
                        //k1++;
1429 1434
                    }
1430
                    //k1++;
1431 1435
                }
1432 1436
            }
1433 1437
            // Le quito los cachos que ya tengo a las geometrias que faltan de
1434
            // geometriesToUnion.
1438
            // uningGeometries.
1435 1439
            BitSet bitSet2 = new BitSet();
1436 1440
            bitSet2.clear();
1437 1441
            int k2=0;
1438
            for (int i=0;i<geometriesUned2.size();i++) {
1439
                Geometry geometryUned2 = (Geometry)geometriesUned2.get(i);
1440
                for (int j=0;j<geometriesToUnion.length;j++) {
1441
                    //System.out.println("!(geometriesToUnion[j].equals(geometryUned2)) = " + !(geometriesToUnion[j].equals(geometryUned2)));
1442
                    if (geometriesToUnion[j].intersects(geometryUned2) && !(geometriesToUnion[j].equals(geometryUned2))) {
1443
                        geometriesToUnion[j] = geometriesToUnion[j].difference(geometryUned2);
1442
            for (int i=0;i<geometriesUned.size();i++) {
1443
                Geometry geometryUned = (Geometry)geometriesUned.get(i);
1444
                for (int j=0;j<uningGeometries.length;j++) {
1445
                    if (uningGeometries[j].intersects(geometryUned) && !(uningGeometries[j].equals(geometryUned))) {
1446
                        uningGeometries[j] = uningGeometries[j].difference(geometryUned);
1444 1447
                        bitSet2.set(k2);
1445
                        //bitSet2.set(j);
1448
                        //bitSet1.set(j);
1449
                        k2++;
1446 1450
                    }
1447
                    k2++;
1448 1451
                }
1449 1452
            }
1450
            //for (int i=0;i<bitSet2.size();i++) {
1451
            //    System.out.println("bitSet2.get(" + i + ") = " + bitSet2.get(i));
1452
            //}
1453 1453
            // Ahora que les he quitado los cachos que ya ten?a, le meto los features que
1454
            // faltaban de uningGeometries
1455
            for (int i=0;i<uningGeometries.length;i++) {
1454
            // faltaban de geometriesToUnion
1455
            for (int i=0;i<geometriesToUnion.length;i++) {
1456 1456
                if (bitSet1.get(i)) {
1457
                    geometriesUned2.add(uningGeometries[i]);
1458
                    Value[] uningRow = new Value[unedLyrFieldNames.length+1];
1457
                    geometriesUned2.add(geometriesToUnion[i]);
1458
                    Value[] unionRow = new Value[unedLyrFieldNames.length+1];
1459 1459
                    for (int k=0;k<lyrToUnionFieldNames.length-1;k++) {
1460
                        uningRow[k] = ValueFactory.createNullValue();
1460
                        unionRow[k] = lyrToUnionDS.getFieldValue(i, k);
1461 1461
                    }
1462 1462
                    for (int k=0;k<uningLyrFieldNames.length-1;k++) {
1463
                        uningRow[k+l] = uningLyrDS.getFieldValue(i, k);
1463
                        unionRow[k+l] = ValueFactory.createNullValue();
1464 1464
                    }
1465
                    uningRow[unedLyrFieldNames.length] = ValueFactory.createValue(i);
1466
                    values.add(uningRow);
1465
                    unionRow[unedLyrFieldNames.length] = ValueFactory.createValue(i);
1466
                    values.add(unionRow);
1467 1467
                }
1468 1468
            }
1469 1469
            // Ahora que les he quitado los cachos que ya ten?a, le meto los features que
1470
            // faltaban de geometriesToUnion
1471
            for (int i=0;i<geometriesToUnion.length;i++) {
1470
            // faltaban de uningGeometries
1471
            for (int i=0;i<uningGeometries.length;i++) {
1472 1472
                if (bitSet2.get(i)) {
1473
                    geometriesUned2.add(geometriesToUnion[i]);
1474
                    Value[] unionRow = new Value[unedLyrFieldNames.length+1];
1473
                    geometriesUned2.add(uningGeometries[i]);
1474
                    Value[] uningRow = new Value[unedLyrFieldNames.length+1];
1475 1475
                    for (int k=0;k<lyrToUnionFieldNames.length-1;k++) {
1476
                        unionRow[k] = lyrToUnionDS.getFieldValue(i, k);
1476
                        uningRow[k] = ValueFactory.createNullValue();
1477 1477
                    }
1478 1478
                    for (int k=0;k<uningLyrFieldNames.length-1;k++) {
1479
                        unionRow[k+l] = ValueFactory.createNullValue();
1479
                        uningRow[k+l] = uningLyrDS.getFieldValue(i, k);
1480 1480
                    }
1481
                    unionRow[unedLyrFieldNames.length] = ValueFactory.createValue(i);
1482
                    values.add(unionRow);
1481
                    uningRow[unedLyrFieldNames.length] = ValueFactory.createValue(i);
1482
                    values.add(uningRow);
1483 1483
                }
1484 1484
            }
1485 1485
            //selectable.setSelection(fBitSet);

Also available in: Unified diff