skrueger/geotools/XMapPaneAction_Select.java

package skrueger.geotools;

import java.awt.Color;
import java.awt.Point;
import java.awt.event.MouseEvent;
import java.awt.event.MouseWheelEvent;
import java.awt.geom.Point2D;
import java.util.Enumeration;
import java.util.Hashtable;
import java.util.Iterator;

import org.geotools.data.memory.MemoryFeatureCollection;
import org.geotools.feature.FeatureCollection;
import org.geotools.map.MapLayer;
import org.opengis.feature.simple.SimpleFeature;
import org.opengis.feature.simple.SimpleFeatureType;
import org.opengis.geometry.DirectPosition;

import schmitzm.geotools.gui.SelectableXMapPane;
import schmitzm.geotools.map.event.FeatureSelectedEvent;
import skrueger.geotools.GeomFilterGenerator.PointFilterGenerator;

import com.vividsolutions.jts.geom.Coordinate;
import com.vividsolutions.jts.geom.Envelope;
import com.vividsolutions.jts.geom.Geometry;
import com.vividsolutions.jts.geom.GeometryFactory;

public abstract class XMapPaneAction_Select implements XMapPaneAction {
        //      
        // /**
        // * Flag fuer Modus "SimpleFeature-Auswahl auf allen (sichtbaren) Layern".
        // *
        // * @see #setState(int)
        // * @see #setState(int)
        // */
        // public static enum SelMode {
        // SELECT_ALL
        // }

        public void performClick(XMapPane xMapPane, MouseEvent ev,
                        DirectPosition geoCoord) {

                SelectableXMapPane sexMapPane = (SelectableXMapPane) xMapPane;

                // calculate a circle radius around the mouse position
                double radius = DEFAULT_DISTANCE_FRACTION
                                * (xMapPane.getMapArea().getWidth() + xMapPane.getMapArea()
                                                .getHeight()) / 2;

                // Fenster-Koordinate in Geo-Koordinate umwandelt
                Point2D geoPoint = xMapPane.getScreenToWorld().transform(ev.getPoint(),
                                null);

                PointFilterGenerator filterGenerator = new PointFilterGenerator(
                                geoCoord, radius);
                Hashtable<MapLayer, FeatureCollection<SimpleFeatureType, SimpleFeature>> result = sexMapPane
                                .findVisibleFeatures(filterGenerator, selectionMode,
                                                new Envelope(geoPoint.getX(), geoPoint.getX(), geoPoint
                                                                .getY(), geoPoint.getY()));

                // Ein Event auslösen für das jeweils nächste Feature pro Layer
                for (Enumeration<MapLayer> element = result.keys(); element
                                .hasMoreElements();) {

                        MapLayer layer = element.nextElement();
                        FeatureCollection<SimpleFeatureType, SimpleFeature> fc = result
                                        .get(layer);
                        FeatureCollection<SimpleFeatureType, SimpleFeature> fcOne;

                        if (fc != null && !fc.isEmpty()) {

                                if (fc.size() > 1) {
                                        // If the result contains more that one feature, we only
                                        // return the nearest one.

                                        SimpleFeature nearestFeature = null;
                                        Double nearestDist = 0.0;

                                        Iterator<SimpleFeature> fcIt = fc.iterator();
                                        try {
                                                com.vividsolutions.jts.geom.Point mousePoint = new GeometryFactory()
                                                                .createPoint(new Coordinate(geoPoint.getX(),
                                                                                geoPoint.getY()));

                                                while (fcIt.hasNext()) {
                                                        SimpleFeature f = fcIt.next();
                                                        Geometry obj = (Geometry) f
                                                                        .getDefaultGeometryProperty().getValue();

                                                        // TODO Hier muss doch irgendwie noch CRS
                                                        // umgewrechnet werden...

                                                        Geometry featureGeometry = (Geometry) obj;

                                                        double distance = featureGeometry
                                                                        .distance(mousePoint);

                                                        if ((nearestFeature == null)
                                                                        || (distance < nearestDist)) {
                                                                nearestFeature = f;
                                                                nearestDist = distance;
                                                        }

                                                }

                                        } finally {
                                                fc.close(fcIt);
                                        }

                                        fcOne = new MemoryFeatureCollection(fc.getSchema());
                                        fc.clear();
                                        fcOne.add(nearestFeature);
                                } else {
                                        fcOne = fc;
                                }

                                // Fire the event with the one selected feature
                                sexMapPane.fireMapPaneEvent(new FeatureSelectedEvent(
                                                sexMapPane, layer, fcOne.getBounds(), fcOne));
                        }
                }

                // If no vector features were found, or we are in SELECT_ALL mode, we
                // check the raster layers now
                if (selectionMode == XMapPane.SELECT_ALL || result.isEmpty()) {
                        sexMapPane.findGridCoverageValuesAndFireEvents(geoPoint,
                                        selectionMode);
                }
        }

        /**
         * Does nothing if initiated by keyboard.
         * 
         * TODO select all features should be assignable to Strg-A
         */
        @Override
        public void performKeyboard(XMapPane mapPane, Object param) {
        }

        /**
         * Default distance fraction used with line and point features. When the
         * user clicks on the map, this tool searches for features within a
         * rectangle of width w centered on the mouse location, where w is the
         * average map side length multiplied by the value of this constant.
         */
        public static final double DEFAULT_DISTANCE_FRACTION = 0.01d;

        private static int selectionMode;

        // @Override
        // public void performClick(XMapPane xMapPane, MouseEvent ev,
        // DirectPosition geoCoord) {
        //                      
        // performSelectionClick(xMapPane, ev, geoCoord, XMapPane.SELECT_ALL);
        // }

        @Override
        public void performDragged(XMapPane mapPane, MouseEvent ev,
                        Point dragStartPos, Point dragLastPos, DirectPosition startCoord,
                        DirectPosition endCoord) {

                SelectableXMapPane sexMapPane = (SelectableXMapPane) mapPane;

                Point mp = ev.getPoint();

                // Ist es eine wirkliche Selektion, oder etwas nur ein Klick?
                if (dragStartPos.x != mp.x && dragStartPos.y != mp.y) {
                        sexMapPane.drawRectangle(sexMapPane.getGraphics(), dragStartPos, ev
                                        .getPoint(), Color.YELLOW);
                }

                // SELECTION!
                sexMapPane.performSelectionEvent(dragStartPos.x, dragStartPos.y, mp.x,
                                mp.y, selectionMode);
        }

        @Override
        public void performDragging(XMapPane mapPane, MouseEvent ev,
                        Point dragStartPos, Point dragLastPos, DirectPosition startCoord,
                        DirectPosition endCoord) {
                if (dragLastPos != null)
                        mapPane.drawRectangle(mapPane.getGraphics(), dragStartPos,
                                        dragLastPos);

                mapPane.drawRectangle(mapPane.getGraphics(), dragStartPos, ev
                                .getPoint(), Color.YELLOW);
        }

        @Override
        public void performWheel(XMapPane mapPane, MouseWheelEvent ev,
                        DirectPosition coord) {
        }

        public static class All extends XMapPaneAction_Select {

                public All() {
                        selectionMode = XMapPane.SELECT_ALL;
                }
        }

        public static class OneFromTop extends XMapPaneAction_Select {

                public OneFromTop() {
                        selectionMode = XMapPane.SELECT_ONE_FROM_TOP;
                }
        }

        public static class Top extends XMapPaneAction_Select {

                public Top() {
                        selectionMode = XMapPane.SELECT_TOP;
                }
        }

}
1	alfonx	653	package skrueger.geotools;
2
3			import java.awt.Color;
4			import java.awt.Point;
5			import java.awt.event.MouseEvent;
6			import java.awt.event.MouseWheelEvent;
7			import java.awt.geom.Point2D;
8			import java.util.Enumeration;
9			import java.util.Hashtable;
10			import java.util.Iterator;
11
12			import org.geotools.data.memory.MemoryFeatureCollection;
13			import org.geotools.feature.FeatureCollection;
14			import org.geotools.map.MapLayer;
15			import org.opengis.feature.simple.SimpleFeature;
16			import org.opengis.feature.simple.SimpleFeatureType;
17			import org.opengis.geometry.DirectPosition;
18
19			import schmitzm.geotools.gui.SelectableXMapPane;
20			import schmitzm.geotools.map.event.FeatureSelectedEvent;
21			import skrueger.geotools.GeomFilterGenerator.PointFilterGenerator;
22
23			import com.vividsolutions.jts.geom.Coordinate;
24			import com.vividsolutions.jts.geom.Envelope;
25			import com.vividsolutions.jts.geom.Geometry;
26			import com.vividsolutions.jts.geom.GeometryFactory;
27
28			public abstract class XMapPaneAction_Select implements XMapPaneAction {
29			//
30			// /**
31			// * Flag fuer Modus "SimpleFeature-Auswahl auf allen (sichtbaren) Layern".
32			// *
33			// * @see #setState(int)
34			// * @see #setState(int)
35			// */
36			// public static enum SelMode {
37			// SELECT_ALL
38			// }
39
40			public void performClick(XMapPane xMapPane, MouseEvent ev,
41			DirectPosition geoCoord) {
42
43			SelectableXMapPane sexMapPane = (SelectableXMapPane) xMapPane;
44
45			// calculate a circle radius around the mouse position
46			double radius = DEFAULT_DISTANCE_FRACTION
47			* (xMapPane.getMapArea().getWidth() + xMapPane.getMapArea()
48			.getHeight()) / 2;
49
50			// Fenster-Koordinate in Geo-Koordinate umwandelt
51			Point2D geoPoint = xMapPane.getScreenToWorld().transform(ev.getPoint(),
52			null);
53
54			PointFilterGenerator filterGenerator = new PointFilterGenerator(
55			geoCoord, radius);
56			Hashtable<MapLayer, FeatureCollection<SimpleFeatureType, SimpleFeature>> result = sexMapPane
57			.findVisibleFeatures(filterGenerator, selectionMode,
58			new Envelope(geoPoint.getX(), geoPoint.getX(), geoPoint
59			.getY(), geoPoint.getY()));
60
61			// Ein Event auslösen für das jeweils nächste Feature pro Layer
62			for (Enumeration<MapLayer> element = result.keys(); element
63			.hasMoreElements();) {
64
65			MapLayer layer = element.nextElement();
66			FeatureCollection<SimpleFeatureType, SimpleFeature> fc = result
67			.get(layer);
68			FeatureCollection<SimpleFeatureType, SimpleFeature> fcOne;
69
70			if (fc != null && !fc.isEmpty()) {
71
72			if (fc.size() > 1) {
73			// If the result contains more that one feature, we only
74			// return the nearest one.
75
76			SimpleFeature nearestFeature = null;
77			Double nearestDist = 0.0;
78
79			Iterator<SimpleFeature> fcIt = fc.iterator();
80			try {
81			com.vividsolutions.jts.geom.Point mousePoint = new GeometryFactory()
82			.createPoint(new Coordinate(geoPoint.getX(),
83			geoPoint.getY()));
84
85			while (fcIt.hasNext()) {
86			SimpleFeature f = fcIt.next();
87			Geometry obj = (Geometry) f
88			.getDefaultGeometryProperty().getValue();
89
90			// TODO Hier muss doch irgendwie noch CRS
91			// umgewrechnet werden...
92
93			Geometry featureGeometry = (Geometry) obj;
94
95			double distance = featureGeometry
96			.distance(mousePoint);
97
98			if ((nearestFeature == null)
99			\|\| (distance < nearestDist)) {
100			nearestFeature = f;
101			nearestDist = distance;
102			}
103
104			}
105
106			} finally {
107			fc.close(fcIt);
108			}
109
110			fcOne = new MemoryFeatureCollection(fc.getSchema());
111			fc.clear();
112			fcOne.add(nearestFeature);
113			} else {
114			fcOne = fc;
115			}
116
117			// Fire the event with the one selected feature
118			sexMapPane.fireMapPaneEvent(new FeatureSelectedEvent(
119			sexMapPane, layer, fcOne.getBounds(), fcOne));
120			}
121			}
122
123			// If no vector features were found, or we are in SELECT_ALL mode, we
124			// check the raster layers now
125			if (selectionMode == XMapPane.SELECT_ALL \|\| result.isEmpty()) {
126			sexMapPane.findGridCoverageValuesAndFireEvents(geoPoint,
127			selectionMode);
128			}
129			}
130
131			/**
132			* Does nothing if initiated by keyboard.
133			*
134			* TODO select all features should be assignable to Strg-A
135			*/
136			@Override
137			public void performKeyboard(XMapPane mapPane, Object param) {
138			}
139
140			/**
141			* Default distance fraction used with line and point features. When the
142			* user clicks on the map, this tool searches for features within a
143			* rectangle of width w centered on the mouse location, where w is the
144			* average map side length multiplied by the value of this constant.
145			*/
146			public static final double DEFAULT_DISTANCE_FRACTION = 0.01d;
147
148			private static int selectionMode;
149
150			// @Override
151			// public void performClick(XMapPane xMapPane, MouseEvent ev,
152			// DirectPosition geoCoord) {
153			//
154			// performSelectionClick(xMapPane, ev, geoCoord, XMapPane.SELECT_ALL);
155			// }
156
157			@Override
158			public void performDragged(XMapPane mapPane, MouseEvent ev,
159			Point dragStartPos, Point dragLastPos, DirectPosition startCoord,
160			DirectPosition endCoord) {
161
162			SelectableXMapPane sexMapPane = (SelectableXMapPane) mapPane;
163
164			Point mp = ev.getPoint();
165
166			// Ist es eine wirkliche Selektion, oder etwas nur ein Klick?
167			if (dragStartPos.x != mp.x && dragStartPos.y != mp.y) {
168			sexMapPane.drawRectangle(sexMapPane.getGraphics(), dragStartPos, ev
169			.getPoint(), Color.YELLOW);
170			}
171
172			// SELECTION!
173			sexMapPane.performSelectionEvent(dragStartPos.x, dragStartPos.y, mp.x,
174			mp.y, selectionMode);
175			}
176
177			@Override
178			public void performDragging(XMapPane mapPane, MouseEvent ev,
179			Point dragStartPos, Point dragLastPos, DirectPosition startCoord,
180			DirectPosition endCoord) {
181			if (dragLastPos != null)
182			mapPane.drawRectangle(mapPane.getGraphics(), dragStartPos,
183			dragLastPos);
184
185			mapPane.drawRectangle(mapPane.getGraphics(), dragStartPos, ev
186			.getPoint(), Color.YELLOW);
187			}
188
189			@Override
190			public void performWheel(XMapPane mapPane, MouseWheelEvent ev,
191			DirectPosition coord) {
192			}
193
194			public static class All extends XMapPaneAction_Select {
195
196			public All() {
197			selectionMode = XMapPane.SELECT_ALL;
198			}
199			}
200
201			public static class OneFromTop extends XMapPaneAction_Select {
202
203			public OneFromTop() {
204			selectionMode = XMapPane.SELECT_ONE_FROM_TOP;
205			}
206			}
207
208			public static class Top extends XMapPaneAction_Select {
209
210			public Top() {
211			selectionMode = XMapPane.SELECT_TOP;
212			}
213			}
214
215			}
Name	Value
svn:eol-style	native
svn:keywords	Id URL
svn:mime-type	text/plain