Statistics
| Revision:

gvsig-vectorediting / org.gvsig.vectorediting / trunk / org.gvsig.vectorediting / org.gvsig.vectorediting.lib / org.gvsig.vectorediting.lib.prov / org.gvsig.vectorediting.lib.prov.ellipse / src / main / java / org / gvsig / vectorediting / lib / prov / ellipse / FilledEllipseCenterAxesEditingProvider.java @ 2109

History | View | Annotate | Download (14.6 KB)

1
/**
2
 * gvSIG. Desktop Geographic Information System.
3
 *
4
 * Copyright ? 2007-2014 gvSIG Association
5
 *
6
 * This program is free software; you can redistribute it and/or
7
 * modify it under the terms of the GNU General Public License
8
 * as published by the Free Software Foundation; either version 2
9
 * of the License, or (at your option) any later version.
10
 *
11
 * This program is distributed in the hope that it will be useful,
12
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14
 * GNU General Public License for more details.
15
 *
16
 * You should have received a copy of the GNU General Public License
17
 * along with this program; if not, write to the Free Software
18
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
19
 * MA  02110-1301, USA.
20
 *
21
 * For any additional information, do not hesitate to contact us
22
 * at info AT gvsig.com, or visit our website www.gvsig.com.
23
 */
24

    
25
package org.gvsig.vectorediting.lib.prov.ellipse;
26

    
27
import java.awt.geom.Point2D;
28
import java.util.ArrayList;
29
import java.util.HashMap;
30
import java.util.List;
31
import java.util.Map;
32
import org.gvsig.euclidean.EuclideanLine2D;
33
import org.gvsig.euclidean.EuclideanManager;
34
import org.gvsig.fmap.dal.exception.DataException;
35

    
36
import org.gvsig.fmap.dal.feature.FeatureStore;
37
import org.gvsig.fmap.geom.Geometry;
38
import org.gvsig.fmap.geom.GeometryLocator;
39
import org.gvsig.fmap.geom.aggregate.MultiSurface;
40
import org.gvsig.fmap.geom.exception.CreateGeometryException;
41
import org.gvsig.fmap.geom.primitive.Curve;
42
import org.gvsig.fmap.geom.primitive.Ellipse;
43
import org.gvsig.fmap.geom.primitive.Line;
44
import org.gvsig.fmap.geom.primitive.Point;
45
import org.gvsig.fmap.geom.type.GeometryType;
46
import org.gvsig.fmap.mapcontext.rendering.symbols.ISymbol;
47
import org.gvsig.tools.dynobject.DynObject;
48
import org.gvsig.tools.locator.LocatorException;
49
import org.gvsig.tools.service.spi.ProviderServices;
50
import org.gvsig.tools.util.ToolsUtilLocator;
51
import org.gvsig.vectorediting.lib.api.DrawingStatus;
52
import org.gvsig.vectorediting.lib.api.EditingServiceParameter;
53
import org.gvsig.vectorediting.lib.api.exceptions.DrawServiceException;
54
import org.gvsig.vectorediting.lib.api.exceptions.FinishServiceException;
55
import org.gvsig.vectorediting.lib.api.exceptions.InvalidEntryException;
56
import org.gvsig.vectorediting.lib.api.exceptions.StartServiceException;
57
import org.gvsig.vectorediting.lib.api.exceptions.StopServiceException;
58
import org.gvsig.vectorediting.lib.spi.AbstractEditingProvider;
59
import org.gvsig.vectorediting.lib.spi.DefaultDrawingStatus;
60
import org.gvsig.vectorediting.lib.spi.DefaultEditingServiceParameter;
61
import org.gvsig.vectorediting.lib.spi.EditingProvider;
62
import org.gvsig.vectorediting.lib.spi.EditingProviderFactory;
63
import org.gvsig.vectorediting.lib.spi.EditingProviderLocator;
64
import org.gvsig.vectorediting.lib.spi.EditingProviderManager;
65
import org.gvsig.vectorediting.lib.spi.EditingProviderServices;
66

    
67
public class FilledEllipseCenterAxesEditingProvider extends AbstractEditingProvider implements
68
EditingProvider {
69

    
70
    protected EditingServiceParameter center;
71

    
72
    protected EditingServiceParameter pointAxisA;
73

    
74
    protected EditingServiceParameter lengthSemiaxisB;
75

    
76
    protected Map<EditingServiceParameter, Object> values;
77

    
78
    protected FeatureStore featureStore;
79

    
80
    public FilledEllipseCenterAxesEditingProvider(ProviderServices providerServices,
81
        DynObject parameters) {
82
        super(providerServices);
83

    
84
        this.featureStore =
85
            (FeatureStore) parameters
86
            .getDynValue(EditingProviderFactory.FEATURE_STORE_FIELD);
87

    
88
        this.center =
89
            new DefaultEditingServiceParameter("center",
90
                "center", EditingServiceParameter.TYPE.POSITION);
91

    
92
        this.pointAxisA =
93
            new DefaultEditingServiceParameter("point_A_axis",
94
                "point_A_axis", EditingServiceParameter.TYPE.POSITION);
95

    
96
        this.lengthSemiaxisB =
97
            new DefaultEditingServiceParameter("length_of_B_semiaxis",
98
                "length_of_B_semiaxis", EditingServiceParameter.TYPE.POSITION,
99
                EditingServiceParameter.TYPE.VALUE);
100
    }
101

    
102
    @Override
103
    public EditingServiceParameter next() {
104
        if (values.get(center) == null) {
105
            return center;
106
        } else if (values.get(pointAxisA) == null) {
107
            return pointAxisA;
108
        } else if (values.get(lengthSemiaxisB) == null) {
109
            return lengthSemiaxisB;
110
        }
111
        return null;
112
    }
113

    
114
    @Override
115
    public DrawingStatus getDrawingStatus(Point mousePosition)
116
        throws DrawServiceException {
117
        DefaultDrawingStatus drawingStatus = new DefaultDrawingStatus();
118
        
119
        EuclideanManager euclideanManager = ToolsUtilLocator.getEuclideanManager();
120

    
121
        EditingProviderManager editingProviderManager =
122
            EditingProviderLocator.getProviderManager();
123
        ISymbol auxiliaryLineSymbolEditing = editingProviderManager.getSymbol("auxiliary-line-symbol-editing");
124
        ISymbol auxiliaryPointSymbolEditing = editingProviderManager.getSymbol("auxiliary-point-symbol-editing");
125

    
126

    
127
        if (values != null) {
128
            EditingProviderServices editingServiceProvider =
129
                (EditingProviderServices) getProviderServices();
130

    
131
            Point centerValue = (Point) values.get(center);
132
            Point pointAxis1Value = (Point) values.get(pointAxisA);
133

    
134
            if (centerValue != null) {
135
                drawingStatus.addStatus(centerValue, auxiliaryPointSymbolEditing, "");
136

    
137

    
138
                if (pointAxis1Value == null) {
139

    
140
                    try {
141
                        int subtype =
142
                            editingServiceProvider.getSubType(featureStore);
143
                        Curve line =
144
                            editingServiceProvider.createLine(
145
                                centerValue, mousePosition, subtype);
146
                        drawingStatus.addStatus(mousePosition, auxiliaryPointSymbolEditing, "");
147
                        drawingStatus.addStatus(line, auxiliaryLineSymbolEditing, "");
148
                        return drawingStatus;
149
                    } catch (Exception e) {
150
                        throw new DrawServiceException(e);
151
                    }
152

    
153
                } else {
154

    
155
                    try {
156
                        int subtype =
157
                            editingServiceProvider.getSubType(featureStore);
158
                        drawingStatus.addStatus(pointAxis1Value, auxiliaryPointSymbolEditing, "");
159
                        drawingStatus.addStatus(centerValue, auxiliaryPointSymbolEditing, "");
160

    
161
                        Curve aAxis =
162
                            editingServiceProvider.createLine(
163
                                centerValue, pointAxis1Value,
164
                                subtype);
165
                        drawingStatus.addStatus(aAxis, auxiliaryLineSymbolEditing, "");
166
                        
167
                        Point firstPointAxis1 = calculateOpositePointAxis(centerValue, pointAxis1Value, subtype);
168
                        
169
                        EuclideanLine2D semiAxisA = euclideanManager.createLine2D(
170
                                centerValue.getX(), 
171
                                centerValue.getY(), 
172
                                pointAxis1Value.getX(),
173
                                pointAxis1Value.getY());
174
                        
175
                        EuclideanLine2D semiAxisB = semiAxisA.getPerpendicular(centerValue.getX(), 
176
                                centerValue.getY());
177
                        
178
                        Point2D pointAxisB = semiAxisB.getNearestPoint(mousePosition.getX(), mousePosition.getY());
179
                        
180
                        double distance = semiAxisA.getDistance(mousePosition.getX(), mousePosition.getY());
181
                        
182
                        addTemporaryGeometryToDrawingStatus(drawingStatus, firstPointAxis1, pointAxis1Value,
183
                            subtype, distance);
184

    
185
                        Line line = editingServiceProvider.createLine(
186
                                centerValue.getX(),
187
                                centerValue.getY(),
188
                                pointAxisB.getX(),
189
                                pointAxisB.getY(),
190
                                subtype);
191
                        drawingStatus.addStatus(line, auxiliaryLineSymbolEditing, "");
192
                        
193
                        drawingStatus.addStatus(aAxis, auxiliaryLineSymbolEditing, "");
194
                        
195
                    } catch (Exception e) {
196
                        throw new DrawServiceException(e);
197
                    }
198
                }
199
            }
200
        }
201
        return drawingStatus;
202
    }
203

    
204
    /**
205
     * @param drawingStatus
206
     * @param firstPointAxis1Value
207
     * @param secondPointAxis1Value
208
     * @param subtype
209
     * @param distance
210
     * @throws CreateGeometryException
211
     */
212
    protected void addTemporaryGeometryToDrawingStatus(DefaultDrawingStatus drawingStatus, Point firstPointAxis1Value,
213
        Point secondPointAxis1Value, int subtype, double distance) throws CreateGeometryException {
214
        Ellipse ellipse = (Ellipse) GeometryLocator.getGeometryManager().create(Geometry.TYPES.ELLIPSE, subtype);
215
        ellipse.setPoints(firstPointAxis1Value, secondPointAxis1Value, distance);
216

    
217
        EditingProviderManager editingProviderManager = EditingProviderLocator.getProviderManager();
218
        ISymbol polygonSymbolEditing = editingProviderManager.getSymbol("polygon-symbol-editing");
219
        drawingStatus.addStatus(ellipse, polygonSymbolEditing, "");
220
    }
221

    
222
    @Override
223
    public void stop() throws StopServiceException {
224
        if (values != null) {
225
            values.clear();
226
        }
227

    
228
    }
229

    
230
    @Override
231
    public List<EditingServiceParameter> getParameters() {
232
        List<EditingServiceParameter> list = new ArrayList<>();
233
        list.add(center);
234
        list.add(pointAxisA);
235
        list.add(lengthSemiaxisB);
236
        return list;
237
    }
238

    
239
    @Override
240
    public void setValue(Object value) throws InvalidEntryException {
241
        EditingServiceParameter parameter = this.next();
242
        validateAndInsertValue(parameter, value);
243
    }
244

    
245
    private void validateAndInsertValue(EditingServiceParameter param,
246
        Object value) throws InvalidEntryException {
247

    
248
        EuclideanManager euclideanManager = ToolsUtilLocator.getEuclideanManager();
249

    
250
        if ((param == center) || (param == pointAxisA)) {
251
            if (value instanceof Point) {
252
                values.put(param, value);
253
            }
254
        } else if (param == lengthSemiaxisB) {
255
            if (value instanceof Point) {
256
                Double length = null;
257

    
258
                try {
259
                    EditingProviderServices editingProviderServices =
260
                        (EditingProviderServices) getProviderServices();
261

    
262
                    Point centerValue =
263
                        (Point) values.get(center);
264
                    Point pointAxisAValue =
265
                        (Point) values.get(pointAxisA);
266
                    int subtype =
267
                        editingProviderServices.getSubType(featureStore);
268
                    
269
                    EuclideanLine2D lineAxisA = euclideanManager.createLine2D(
270
                            centerValue.getX(),
271
                            centerValue.getY(),
272
                            pointAxisAValue.getX(),
273
                            pointAxisAValue.getY()
274
                    );
275
                        
276
                    length = lineAxisA.getDistance(((Point)value).getX(), ((Point)value).getY());
277

    
278
                } catch (DataException e) {
279
                    throw new InvalidEntryException(e);
280
                }
281

    
282
                values.put(param, length);
283

    
284
            } else if (value instanceof Double) {
285

    
286
                if ((((Double) value) - 0.01) > 0) {
287
                    values.put(param, value);
288
                }
289
            }
290
        }
291
    }
292

    
293
    @Override
294
    public Geometry finish() throws FinishServiceException {
295
        if (values != null) {
296

    
297
            EditingProviderServices editingProviderServices =
298
                (EditingProviderServices) getProviderServices();
299

    
300
            Point centerValue = (Point) values.get(center);
301
            Point pointAxis1Value = (Point) values.get(pointAxisA);
302
            double lengthSemiaxis2Value = (Double) values.get(lengthSemiaxisB);
303

    
304
            if ((center != null)
305
                && (pointAxis1Value != null) && (lengthSemiaxis2Value > 0)) {
306

    
307

    
308
                try {
309
                    int subtype = editingProviderServices.getSubType(featureStore);
310
                    GeometryType storeGeomType = editingProviderServices.getGeomType(featureStore);
311

    
312
                    Ellipse ellipse =
313
                        (Ellipse) GeometryLocator.getGeometryManager().create(Geometry.TYPES.ELLIPSE, subtype);
314
                    
315
                    
316
                    Point firstPointAxis = calculateOpositePointAxis(centerValue, pointAxis1Value, subtype);
317
                    
318
                    ellipse.setPoints(firstPointAxis, pointAxis1Value, lengthSemiaxis2Value);
319

    
320
                    if (storeGeomType.isTypeOf(MULTISURFACE)) {
321
                        MultiSurface multisurface;
322
                        multisurface =
323
                            GeometryLocator.getGeometryManager().createMultiSurface(
324
                                storeGeomType.getSubType());
325
                        multisurface.addSurface((Ellipse) ellipse);
326
                        return multisurface;
327
                    }
328

    
329
                    return ellipse;
330
                } catch (Exception e) {
331
                    throw new FinishServiceException(e);
332
                }
333
            }
334
        }
335
        return null;
336
    }
337

    
338
    protected Point calculateOpositePointAxis(Point centerValue, Point pointAxis1Value, int subtype) throws CreateGeometryException, LocatorException {
339
        Point oppositePointAxis = (Point)GeometryLocator.getGeometryManager().create(Geometry.TYPES.POINT, subtype);
340
        oppositePointAxis.setX(centerValue.getX()-(pointAxis1Value.getX()-centerValue.getX()));
341
        oppositePointAxis.setY(centerValue.getY()-(pointAxis1Value.getY()-centerValue.getY()));
342
        return oppositePointAxis;
343
    }
344

    
345
    @Override
346
    public void finishAndStore() throws FinishServiceException {
347
        EditingProviderServices editingProviderServices =
348
            (EditingProviderServices) getProviderServices();
349
        Geometry geometry = finish();
350
        editingProviderServices.insertGeometryIntoFeatureStore(geometry,
351
            featureStore);
352
    }
353

    
354
    @Override
355
    public void start() throws StartServiceException {
356
        values = new HashMap<>();
357
    }
358

    
359
    @Override
360
    public String getName() {
361
        return FilledEllipseCenterAxesEditingProviderFactory.PROVIDER_NAME;
362
    }
363

    
364
}