| gvSIG desktop 1

/* gvSIG. Geographic Information System of the Valencian Government

 *

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

 * of the Valencian Government (CIT)

 * 

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License

 * as published by the Free Software Foundation; either version 2

 * of the License, or (at your option) any later version.

 * 

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 * 

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, 

 * MA  02110-1301, USA.

 * 

 */

package org.gvsig.editing.gui.cad.tools;

import java.awt.Image;

import java.awt.event.InputEvent;

import java.awt.event.MouseEvent;

import java.awt.geom.Point2D;

import java.util.ArrayList;

import java.util.List;

import com.vividsolutions.jts.geom.Coordinate;

import com.vividsolutions.jts.geom.Geometry;

import com.vividsolutions.jts.geom.GeometryCollection;

import com.vividsolutions.jts.geom.GeometryFactory;

import com.vividsolutions.jts.geom.LineString;

import com.vividsolutions.jts.geom.MultiLineString;

import com.vividsolutions.jts.geom.MultiPoint;

import com.vividsolutions.jts.geom.MultiPolygon;

import com.vividsolutions.jts.geom.Point;

import com.vividsolutions.jts.geom.Polygon;

import com.vividsolutions.jts.geom.PrecisionModel;

import org.gvsig.andami.PluginServices;

import org.gvsig.andami.messages.NotificationManager;

import org.gvsig.editing.gui.cad.DefaultCADTool;

import org.gvsig.editing.gui.cad.exception.CommandException;

import org.gvsig.editing.gui.cad.tools.smc.SplitGeometryCADToolContext;

import org.gvsig.editing.gui.cad.tools.split.SplitStrategy;

import org.gvsig.editing.layers.VectorialLayerEdited;

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

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

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

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

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

import org.gvsig.fmap.geom.GeometryLocator;

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

import org.gvsig.fmap.geom.operation.GeometryOperationException;

import org.gvsig.fmap.geom.operation.GeometryOperationNotSupportedException;

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

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

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

import org.gvsig.fmap.geom.util.Converter;

import org.gvsig.fmap.mapcontext.layers.SpatialCache;

import org.gvsig.fmap.mapcontext.layers.vectorial.FLyrVect;

import org.gvsig.fmap.mapcontrol.MapControlDrawer;

import org.gvsig.tools.dispose.DisposableIterator;

import org.gvsig.tools.dispose.DisposeUtils;

import org.gvsig.tools.locator.LocatorException;

import statemap.State;

/**

 * CAD Tool which splits the selected geometries of a vectorial editing

 * layer with a digitized polyline.

 * 

 * 

 * @author Alvaro Zabala

 * 

 */

public class SplitGeometryCADTool extends DefaultCADTool {

    /**

     * String representation of this tool (used for example to active the tool

     * in mapcontrol)

     */

    public static final String SPLIT_GEOMETRY_TOOL_NAME = "_split_geometry";

    /**

     * finite state machine for this CAD tool

     */

    protected SplitGeometryCADToolContext _fsm;

    /**

     * Flag to mark if the digitized line has been finished.

     */

    protected boolean digitizingFinished = false;

    /**

     * Collection of digitized geometries

     */

    protected List<Point2D> clickedPoints;

    /**

     * Initialization method.

     */

    public void init() {

        digitizingFinished = false;

        _fsm = new SplitGeometryCADToolContext(this);

        setNextTool(SplitGeometryCADTool.SPLIT_GEOMETRY_TOOL_NAME);

    }

    public boolean isDigitizingFinished() {

        return digitizingFinished;

    }

    public String toString() {

        return SplitGeometryCADTool.SPLIT_GEOMETRY_TOOL_NAME;

    }

    public void finishDigitizedLine() {

    }

    public Coordinate[] getPoint2DAsCoordinates(Point2D[] point2d) {

        Coordinate[] solution = new Coordinate[point2d.length];

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

            solution[i] = new Coordinate(point2d[i].getX(), point2d[i].getY());

        }

        return solution;

    }

    public void splitSelectedGeometryWithDigitizedLine() {

        Point2D[] clickedPts = new Point2D[this.clickedPoints.size()];

        clickedPoints.toArray(clickedPts);

        Coordinate[] digitizedCoords = getPoint2DAsCoordinates(clickedPts);

        LineString splittingLs =

            new GeometryFactory(new PrecisionModel(10000))

                .createLineString(digitizedCoords);

        DisposableIterator selected = null;

        try {

            VectorialLayerEdited vle = getVLE();

            FeatureStore store = vle.getFeatureStore();

            selected = store.getFeatureSelection().iterator();

            getCadToolAdapter().getMapControl().getMapContext()

                .beginAtomicEvent();

            store.beginEditingGroup(getName());

            while (selected.hasNext()) {

                Feature feature = (Feature) selected.next();

                org.gvsig.fmap.geom.Geometry ig = feature.getDefaultGeometry();

                Geometry jtsGeo = (Geometry)ig.invokeOperation("toJTS", null);

                if (jtsGeo == null)

                    return;

                Geometry splitGeo = SplitStrategy.splitOp(jtsGeo, splittingLs);

                if (splitGeo instanceof GeometryCollection

                    && ((GeometryCollection) splitGeo).getNumGeometries() > 1) {

                    GeometryCollection gc = (GeometryCollection) splitGeo;

                    ArrayList<Geometry> geoms0 = new ArrayList<Geometry>();

                    ArrayList<Geometry> geoms1 = new ArrayList<Geometry>();

                    if (gc.getNumGeometries() > 2) {

                        Geometry[] splitGroups =

                            createSplitGroups(jtsGeo, splittingLs);

                        if (splitGroups.length == 0) {

                            continue;

                        }

                        for (int j = 0; j < gc.getNumGeometries(); j++) {

                            Geometry g = gc.getGeometryN(j);

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

                            if (splitGroups[k].contains(g)) {

                                    geoms0.add(g);

                                } else {

                                    geoms1.add(g);

                                }

                            }

                        }

                    } else

                        if (gc.getNumGeometries() == 2) {

                            geoms0.add(gc.getGeometryN(0));

                            geoms1.add(gc.getGeometryN(1));

                        } else {

                            continue;

                        }

                    GeometryCollection gc0 =

                        createMulti(geoms0, gc.getFactory());

                    // for(int j = 0; j < gc.getNumGeometries(); j++){

                    // Geometry g = gc.getGeometryN(j);

                    org.gvsig.fmap.geom.Geometry fmapGeo =

                        Converter.jtsToGeometry(gc0);

                    // if (j==0){

                    EditableFeature eFeature = feature.getEditable();

                    eFeature.setGeometry(store.getDefaultFeatureType()

                        .getDefaultGeometryAttributeName(), fmapGeo);

                    store.update(eFeature);

                    // }else{

                    GeometryCollection gc1 =

                        createMulti(geoms1, gc.getFactory());

                    fmapGeo = Converter.jtsToGeometry(gc1);

                    EditableFeature newFeature =

                        store.createNewFeature(store.getDefaultFeatureType(),

                            feature);

                    newFeature.setGeometry(store.getDefaultFeatureType()

                        .getDefaultGeometryAttributeName(), fmapGeo);

                    store.insert(newFeature);

                    SpatialCache spatialCache =

                        ((FLyrVect) vle.getLayer()).getSpatialCache();

                    Envelope envelope = fmapGeo.getEnvelope();

                    spatialCache.insert(envelope, fmapGeo);

                    // }

                    // }//for j

                }// if splitGeo

            }

            store.endEditingGroup();

            getCadToolAdapter().getMapControl().getMapContext()

                .endAtomicEvent();

        } catch (Exception ex) {

            PluginServices.getLogger().error("Error splitting geom", ex);

        } finally {

            DisposeUtils.dispose(selected);

        }

    }

    private GeometryCollection createMulti(ArrayList<Geometry> geoms,

        GeometryFactory factory) {

        if (geoms.size() == 0)

            return null;

        if (geoms.get(0) instanceof Polygon) {

            return new MultiPolygon((Polygon[]) geoms.toArray(new Polygon[0]),

                factory);

        } else

            if (geoms.get(0) instanceof LineString) {

                return new MultiLineString(

                    (LineString[]) geoms.toArray(new LineString[0]), factory);

            } else

                if (geoms.get(0) instanceof Point) {

                    return new MultiPoint(

                        (Point[]) geoms.toArray(new Point[0]), factory);

                }

        return null;

    }

    private Geometry[] createSplitGroups(Geometry splitGeo,

        LineString splittingLs) {

        try {

            Geometry[] geomsJTS = new Geometry[2];

            Geometry r = splitGeo.getEnvelope();

            Geometry splitG = SplitStrategy.splitOp(r, splittingLs);

            if (splitG instanceof GeometryCollection

                && ((GeometryCollection) splitG).getNumGeometries() > 1) {

                GeometryCollection gc = (GeometryCollection) splitG;

                for (int j = 0; j < gc.getNumGeometries(); j++) {

                    geomsJTS[j] = gc.getGeometryN(j);

                }

            }

            return geomsJTS;

        } catch (Exception e) {

            NotificationManager.showMessageError(

                PluginServices.getText(this, "line_not_cross_rectangle"), e);

        }

        return null;

    }

    public void end() {

        getCadToolAdapter().refreshEditedLayer();

        init();

    }

    public void addOption(String s) {

        State actualState = _fsm.getPreviousState();

        String status = actualState.getName();

        if (s.equals(PluginServices.getText(this, "cancel"))) {

            init();

            return;

        }

        if (status.equals("TopologicalEdition.FirstPoint")) {

            return;

        }

        init();

    }

    public void addPoint(double x, double y, InputEvent event) {

        State actualState = _fsm.getPreviousState();

        String status = actualState.getName();

        if (status.equals("SplitGeometry.FirstPoint")) {

            clickedPoints = new ArrayList<Point2D>();

            clickedPoints.add(new Point2D.Double(x, y));

        } else

            if (status.equals("SplitGeometry.DigitizingLine")) {

                clickedPoints.add(new Point2D.Double(x, y));

                if (event != null && ((MouseEvent) event).getClickCount() == 2) {

                    digitizingFinished = true;

                    finishDigitizedLine();

                    splitSelectedGeometryWithDigitizedLine();

                    end();

                }

            }

    }

    public void addValue(double d) {

    }

    /**

     * Draws a polyline with the clicked digitized points in the specified

     * graphics.

     * 

     * @param g2

     *            graphics on to draw the polyline

     * @param x

     *            last x mouse pointer position

     * @param y

     *            last y mouse pointer position

     */

    protected void drawPolyLine(MapControlDrawer renderer, double x, double y) {

        GeneralPathX gpx =

            new GeneralPathX(GeneralPathX.WIND_EVEN_ODD, clickedPoints.size());

        Point2D firstPoint = clickedPoints.get(0);

        gpx.moveTo(firstPoint.getX(), firstPoint.getY());

        for (int i = 1; i < clickedPoints.size(); i++) {

            Point2D clickedPoint = clickedPoints.get(i);

            gpx.lineTo(clickedPoint.getX(), clickedPoint.getY());

        }

        gpx.lineTo(x, y);

        org.gvsig.fmap.geom.Geometry geom;

        try {

            geom =

                GeometryLocator.getGeometryManager().createCurve(gpx,

                    SUBTYPES.GEOM2D);

            renderer.draw(geom, mapControlManager.getGeometrySelectionSymbol());

        } catch (LocatorException e) {

            e.printStackTrace();

        } catch (CreateGeometryException e) {

            e.printStackTrace();

        }

    }

    private void drawRectangleOfSplit(MapControlDrawer renderer)

        throws GeometryOperationNotSupportedException,

        GeometryOperationException, DataException,

        CreateGeometryException {

        VectorialLayerEdited vle = getVLE();

        FeatureStore store = vle.getFeatureStore();

        DisposableIterator selected = null;

        try {

            selected = store.getFeatureSelection().iterator();

            while (selected.hasNext()) {

                Feature feature = (Feature) selected.next();

                org.gvsig.fmap.geom.Geometry ig = feature.getDefaultGeometry();

                Geometry jtsG = (Geometry)ig.invokeOperation("toJTS", null);

                if (jtsG != null && jtsG instanceof GeometryCollection

                    && jtsG.getNumGeometries() > 1) {

                    /*

                    org.gvsig.fmap.geom.Geometry r =

                        ig.getEnvelope().getGeometry();

                        */

                    // get perimeter of envelope to prevent

                    // opaque rectangle

                    org.gvsig.fmap.geom.Geometry geom =

                        GeometryLocator.getGeometryManager().createCurve(

                            ig.getEnvelope().getGeometry().getGeneralPath(),

                            SUBTYPES.GEOM2D);

                    renderer

                        .draw(geom, mapControlManager.getAxisReferenceSymbol());

                }

            }

        } finally {

            DisposeUtils.dispose(selected);

        }

    }

    public void drawOperation(MapControlDrawer renderer, double x, double y) {

        State actualState = _fsm.getState();

        String status = actualState.getName();

        try {

            drawRectangleOfSplit(renderer);

            // draw splitting line

            if ((status.equals("SplitGeometry.DigitizingLine"))) {

                drawPolyLine(renderer, x, y);

            }

            // draw selection

            Image imgSel = getVLE().getSelectionImage();

            renderer.drawImage(imgSel, 0, 0);

        } catch (Exception e) {

            PluginServices.getLogger().error("Error drawing Editing Selection",

                e);

        }

    }

    public String getName() {

        return PluginServices.getText(this, "split_geometry_shell");

    }

    public void transition(double x, double y, InputEvent event) {

        try {

            _fsm.addPoint(x, y, event);

        } catch (Exception e) {

            init();

        }

    }

    public void transition(double d) {

        _fsm.addValue(d);

    }

    public void transition(String s) throws CommandException {

        if (!super.changeCommand(s)) {

            _fsm.addOption(s);

        }

    }

    @Override

    public boolean isApplicable(GeometryType geometryType) {

        return true;

    }

    @Override

    protected int[] getSupportedGeometryTypes() {

        return null;

    }

}