Revision 2173 org.gvsig.vectorediting.offset/trunk/org.gvsig.vectorediting.offset/org.gvsig.vectorediting.offset.lib/org.gvsig.vectorediting.offset.lib.prov/org.gvsig.vectorediting.offset.lib.prov.offset/src/main/java/org/gvsig/vectorediting/offset/lib/prov/offset/OffsetEditingProvider.java
| OffsetEditingProvider.java | ||
|---|---|---|
| 21 | 21 |
* For any additional information, do not hesitate to contact us |
| 22 | 22 |
* at info AT gvsig.com, or visit our website www.gvsig.com. |
| 23 | 23 |
*/ |
| 24 |
|
|
| 25 | 24 |
package org.gvsig.vectorediting.offset.lib.prov.offset; |
| 26 | 25 |
|
| 27 |
import java.awt.Color; |
|
| 28 | 26 |
import java.util.ArrayList; |
| 29 | 27 |
import java.util.HashMap; |
| 30 | 28 |
import java.util.LinkedHashMap; |
| 31 | 29 |
import java.util.List; |
| 32 | 30 |
import java.util.Map; |
| 33 |
|
|
| 31 |
import org.apache.commons.lang3.StringUtils; |
|
| 34 | 32 |
import org.gvsig.fmap.dal.exception.DataException; |
| 35 | 33 |
import org.gvsig.fmap.dal.feature.EditableFeature; |
| 36 | 34 |
import org.gvsig.fmap.dal.feature.Feature; |
| ... | ... | |
| 58 | 56 |
import org.gvsig.fmap.geom.primitive.Polygon; |
| 59 | 57 |
import org.gvsig.fmap.geom.primitive.Spline; |
| 60 | 58 |
import org.gvsig.fmap.geom.primitive.Surface; |
| 61 |
import org.gvsig.fmap.mapcontext.MapContextLocator; |
|
| 62 | 59 |
import org.gvsig.fmap.mapcontext.rendering.symbols.ISymbol; |
| 63 |
import org.gvsig.fmap.mapcontext.rendering.symbols.SymbolManager; |
|
| 64 | 60 |
import org.gvsig.tools.ToolsLocator; |
| 65 | 61 |
import org.gvsig.tools.dispose.DisposableIterator; |
| 66 | 62 |
import org.gvsig.tools.dynobject.DynObject; |
| ... | ... | |
| 83 | 79 |
import org.gvsig.vectorediting.lib.spi.EditingProviderServices; |
| 84 | 80 |
|
| 85 | 81 |
public class OffsetEditingProvider extends AbstractEditingProvider implements |
| 86 |
EditingProvider {
|
|
| 82 |
EditingProvider {
|
|
| 87 | 83 |
|
| 88 |
private final Double PRECISION = new Double(1.0e-5);
|
|
| 84 |
private static final Double PRECISION = 1.0e-5;
|
|
| 89 | 85 |
|
| 90 |
private I18nManager i18nManager = ToolsLocator.getI18nManager();
|
|
| 86 |
private static final String LEFT = "_left";
|
|
| 91 | 87 |
|
| 92 |
private EditingServiceParameter selectionParameter;
|
|
| 88 |
private static final String RIGHT = "_right";
|
|
| 93 | 89 |
|
| 94 |
private EditingServiceParameter offsetParameter;
|
|
| 90 |
private final EditingServiceParameter selectionParameter;
|
|
| 95 | 91 |
|
| 96 |
private EditingServiceParameter deleteOriginalGeometriesParameter;
|
|
| 92 |
private final EditingServiceParameter offsetParameter;
|
|
| 97 | 93 |
|
| 94 |
private final EditingServiceParameter sideParameter; |
|
| 95 |
|
|
| 96 |
private final EditingServiceParameter deleteOriginalGeometriesParameter; |
|
| 97 |
|
|
| 98 | 98 |
private boolean deleteOriginalGeometries = false; |
| 99 | 99 |
|
| 100 | 100 |
private Map<EditingServiceParameter, Object> values; |
| 101 | 101 |
|
| 102 |
private Map<String, String> options; |
|
| 102 |
private final Map<String, String> options;
|
|
| 103 | 103 |
|
| 104 |
private FeatureStore featureStore; |
|
| 104 |
private final FeatureStore featureStore;
|
|
| 105 | 105 |
|
| 106 | 106 |
public OffsetEditingProvider(ProviderServices providerServices, DynObject parameters) {
|
| 107 | 107 |
super(providerServices); |
| 108 | 108 |
this.featureStore = (FeatureStore) parameters.getDynValue(EditingProviderFactory.FEATURE_STORE_FIELD); |
| 109 |
I18nManager i18nManager = ToolsLocator.getI18nManager(); |
|
| 109 | 110 |
|
| 110 |
this.selectionParameter =
|
|
| 111 |
new DefaultEditingServiceParameter("selection",
|
|
| 112 |
i18nManager.getTranslation("selection"), TYPE.SELECTION);
|
|
| 111 |
this.selectionParameter |
|
| 112 |
= new DefaultEditingServiceParameter("selection",
|
|
| 113 |
i18nManager.getTranslation("selection"), TYPE.SELECTION);
|
|
| 113 | 114 |
|
| 114 |
this.offsetParameter =
|
|
| 115 |
new DefaultEditingServiceParameter("offset_distance",
|
|
| 116 |
i18nManager.getTranslation("offset_distance"),
|
|
| 117 |
TYPE.POSITION, TYPE.VALUE);
|
|
| 115 |
this.offsetParameter |
|
| 116 |
= new DefaultEditingServiceParameter("offset_distance",
|
|
| 117 |
i18nManager.getTranslation("offset_distance"),
|
|
| 118 |
TYPE.POSITION, TYPE.VALUE, TYPE.DISTANCE);
|
|
| 118 | 119 |
|
| 119 |
this.options = new LinkedHashMap<String, String>(); |
|
| 120 |
Map<String, String> sideOptions = new HashMap<>(); |
|
| 121 |
sideOptions.put(LEFT, i18nManager.getTranslation(LEFT)); |
|
| 122 |
sideOptions.put(RIGHT, i18nManager.getTranslation(RIGHT)); |
|
| 123 |
|
|
| 124 |
this.sideParameter |
|
| 125 |
= new DefaultEditingServiceParameter("side",
|
|
| 126 |
i18nManager.getTranslation("_side"),
|
|
| 127 |
sideOptions, |
|
| 128 |
TYPE.OPTION, TYPE.POSITION); |
|
| 129 |
|
|
| 130 |
this.options = new LinkedHashMap<>(); |
|
| 120 | 131 |
options.put(i18nManager.getTranslation("short_yes"),
|
| 121 |
"delete_original_geometries"); |
|
| 132 |
"delete_original_geometries");
|
|
| 122 | 133 |
options.put(i18nManager.getTranslation("short_no"),
|
| 123 |
"keep_original_geometries"); |
|
| 134 |
"keep_original_geometries");
|
|
| 124 | 135 |
|
| 125 |
EditingProviderServices editingProviderServices =
|
|
| 126 |
(EditingProviderServices) getProviderServices();
|
|
| 136 |
// EditingProviderServices editingProviderServices
|
|
| 137 |
// = (EditingProviderServices) getProviderServices();
|
|
| 127 | 138 |
|
| 128 |
String consoleMsg =
|
|
| 129 |
editingProviderServices.makeConsoleMessage(
|
|
| 130 |
"delete_original_geometries_question", options); |
|
| 139 |
String consoleMsg |
|
| 140 |
= ((EditingProviderServices)providerServices).makeConsoleMessage(
|
|
| 141 |
"delete_original_geometries_question", options);
|
|
| 131 | 142 |
|
| 132 |
this.deleteOriginalGeometriesParameter =
|
|
| 133 |
new DefaultEditingServiceParameter("Delete original geometries",
|
|
| 134 |
consoleMsg, options, TYPE.OPTION); |
|
| 143 |
this.deleteOriginalGeometriesParameter |
|
| 144 |
= new DefaultEditingServiceParameter("Delete original geometries",
|
|
| 145 |
consoleMsg, options, TYPE.OPTION);
|
|
| 135 | 146 |
|
| 136 | 147 |
} |
| 137 | 148 |
|
| 149 |
@Override |
|
| 138 | 150 |
public EditingServiceParameter next() {
|
| 139 | 151 |
|
| 140 | 152 |
if (values.get(selectionParameter) == null) {
|
| 141 | 153 |
return selectionParameter; |
| 142 | 154 |
} else if (values.get(offsetParameter) == null) {
|
| 143 | 155 |
return offsetParameter; |
| 144 |
} else if (values.get(deleteOriginalGeometriesParameter) == null) {
|
|
| 156 |
} else if (values.get(sideParameter) == null) {
|
|
| 157 |
Object offsetValue = values.get(offsetParameter); |
|
| 158 |
if (!(offsetValue instanceof Point)) {
|
|
| 159 |
Double distance = (Double) offsetValue; |
|
| 160 |
if (distance >= 0) {
|
|
| 161 |
return sideParameter; |
|
| 162 |
} |
|
| 163 |
} |
|
| 164 |
} |
|
| 165 |
|
|
| 166 |
if (values.get(deleteOriginalGeometriesParameter) == null) {
|
|
| 145 | 167 |
return this.deleteOriginalGeometriesParameter; |
| 146 | 168 |
} |
| 147 | 169 |
|
| 148 | 170 |
return null; |
| 149 | 171 |
} |
| 150 | 172 |
|
| 173 |
@Override |
|
| 151 | 174 |
public DrawingStatus getDrawingStatus(Point mousePosition) throws DrawServiceException {
|
| 152 | 175 |
DefaultDrawingStatus drawingStatus = new DefaultDrawingStatus(); |
| 153 |
EditingProviderManager editingProviderManager =
|
|
| 154 |
EditingProviderLocator.getProviderManager(); |
|
| 176 |
EditingProviderManager editingProviderManager |
|
| 177 |
= EditingProviderLocator.getProviderManager();
|
|
| 155 | 178 |
// ISymbol auxiliaryLineSymbolEditing = editingProviderManager.getSymbol("auxiliary-line-symbol-editing");
|
| 156 | 179 |
ISymbol auxiliaryPointSymbolEditing = editingProviderManager.getSymbol("auxiliary-point-symbol-editing");
|
| 157 | 180 |
ISymbol auxiliaryLineSymbolEditingDirection = editingProviderManager.getSymbol("auxiliary-line-symbol-editing-direction");
|
| 158 | 181 |
ISymbol lineSymbolEditing = editingProviderManager.getSymbol("line-symbol-editing");
|
| 159 | 182 |
ISymbol polygonSymbolEditing = editingProviderManager.getSymbol("polygon-symbol-editing");
|
| 160 |
|
|
| 161 |
|
|
| 162 |
|
|
| 163 |
FeatureSelection selected = |
|
| 164 |
(FeatureSelection) values.get(selectionParameter); |
|
| 183 |
|
|
| 184 |
FeatureSelection selected |
|
| 185 |
= (FeatureSelection) values.get(selectionParameter); |
|
| 165 | 186 |
try {
|
| 166 | 187 |
if ((selected != null) && !selected.isEmpty()) {
|
| 167 |
Point point = null; |
|
| 188 |
Point point; // = null;
|
|
| 168 | 189 |
double distance = 0.0; |
| 190 |
double side = 1.0; |
|
| 169 | 191 |
Object offsetValue = values.get(offsetParameter); |
| 170 |
if (offsetValue != null){
|
|
| 192 |
|
|
| 193 |
if (offsetValue != null) {
|
|
| 171 | 194 |
if (offsetValue instanceof Point) {
|
| 172 |
point = (Point) offsetValue;
|
|
| 195 |
distance = Math.abs(getMinDistance(selected, (Point) offsetValue));
|
|
| 173 | 196 |
} else {
|
| 174 | 197 |
distance = (Double) offsetValue; |
| 175 | 198 |
} |
| 199 |
|
|
| 200 |
Object sideValue = values.get(sideParameter); |
|
| 201 |
if (sideValue == null) {
|
|
| 202 |
point = mousePosition; |
|
| 203 |
side = Math.signum(getMinDistance(selected, point)); |
|
| 204 |
} else {
|
|
| 205 |
Double signum = getSideSignum((String) sideValue); |
|
| 206 |
if (signum != null) {
|
|
| 207 |
side = signum; |
|
| 208 |
} |
|
| 209 |
} |
|
| 176 | 210 |
} else {
|
| 177 | 211 |
point = mousePosition; |
| 178 | 212 |
distance = getMinDistance(selected, point); |
| 179 | 213 |
} |
| 180 | 214 |
|
| 181 |
|
|
| 182 | 215 |
DisposableIterator it; |
| 183 | 216 |
it = selected.fastIterator(); |
| 184 | 217 |
|
| 185 | 218 |
while (it.hasNext()) {
|
| 186 | 219 |
Feature feat = (Feature) it.next(); |
| 187 |
Geometry transformedGeometry = feat.getDefaultGeometry().offset(distance); |
|
| 220 |
Geometry transformedGeometry = feat.getDefaultGeometry().offset(distance * side);
|
|
| 188 | 221 |
|
| 189 | 222 |
ISymbol symbol = null; |
| 190 | 223 |
if (transformedGeometry instanceof Curve || transformedGeometry instanceof MultiCurve) {
|
| ... | ... | |
| 222 | 255 |
* @throws GeometryException |
| 223 | 256 |
*/ |
| 224 | 257 |
private double getMinDistance(FeatureSelection selected, Point point) throws DataException, GeometryOperationNotSupportedException, GeometryOperationException, GeometryException {
|
| 225 |
double minorDistance=Double.POSITIVE_INFINITY;
|
|
| 258 |
double minorDistance = Double.POSITIVE_INFINITY;
|
|
| 226 | 259 |
DisposableIterator it; |
| 227 | 260 |
it = selected.fastIterator(); |
| 228 | 261 |
while (it.hasNext()) {
|
| 229 | 262 |
Feature feat = (Feature) it.next(); |
| 230 | 263 |
Geometry geometry = feat.getDefaultGeometry(); |
| 231 | 264 |
double distance = getDistance(geometry, point); |
| 232 |
if(distance < minorDistance){
|
|
| 265 |
if (distance < minorDistance) {
|
|
| 233 | 266 |
minorDistance = distance; |
| 234 | 267 |
} |
| 235 | 268 |
} |
| ... | ... | |
| 248 | 281 |
*/ |
| 249 | 282 |
private double getDistance(Geometry geometry, Point point) throws GeometryOperationNotSupportedException, GeometryOperationException, GeometryException {
|
| 250 | 283 |
GeometryManager geomManager = GeometryLocator.getGeometryManager(); |
| 251 |
if(geometry instanceof Arc){
|
|
| 252 |
Arc arc = (Arc)geometry; |
|
| 284 |
if (geometry instanceof Arc) {
|
|
| 285 |
Arc arc = (Arc) geometry;
|
|
| 253 | 286 |
Point center = arc.getCenterPoint(); |
| 254 | 287 |
double radius = center.distance(arc.getInitPoint()); |
| 255 |
double distance = center.distance(point)-radius;
|
|
| 288 |
double distance = center.distance(point) - radius;
|
|
| 256 | 289 |
return distance; |
| 257 | 290 |
} |
| 258 | 291 |
|
| 259 |
if(geometry instanceof Circle){
|
|
| 260 |
Circle circle = (Circle)geometry; |
|
| 261 |
return circle.getCenter().distance(point)-circle.getRadious();
|
|
| 292 |
if (geometry instanceof Circle) {
|
|
| 293 |
Circle circle = (Circle) geometry;
|
|
| 294 |
return circle.getCenter().distance(point) - circle.getRadious();
|
|
| 262 | 295 |
} |
| 263 |
if(geometry instanceof Circumference){
|
|
| 264 |
Circumference circumference = (Circumference)geometry; |
|
| 265 |
return circumference.getCenter().distance(point)-circumference.getRadious();
|
|
| 296 |
if (geometry instanceof Circumference) {
|
|
| 297 |
Circumference circumference = (Circumference) geometry;
|
|
| 298 |
return circumference.getCenter().distance(point) - circumference.getRadious();
|
|
| 266 | 299 |
} |
| 267 |
if(geometry instanceof PeriEllipse){
|
|
| 300 |
if (geometry instanceof PeriEllipse) {
|
|
| 268 | 301 |
double minDistance = Double.POSITIVE_INFINITY; |
| 269 |
PeriEllipse ellipse = (PeriEllipse)geometry; |
|
| 302 |
PeriEllipse ellipse = (PeriEllipse) geometry;
|
|
| 270 | 303 |
Geometry[] closestPoints = point.closestPoints(ellipse); |
| 271 |
if (closestPoints!=null){
|
|
| 304 |
if (closestPoints != null) {
|
|
| 272 | 305 |
for (int i = 0; i < closestPoints.length; i++) {
|
| 273 | 306 |
Geometry closestPoint = closestPoints[i]; |
| 274 | 307 |
if (!point.equals(closestPoint)) {
|
| ... | ... | |
| 279 | 312 |
} |
| 280 | 313 |
} |
| 281 | 314 |
} |
| 282 |
Ellipse auxEllipse = (Ellipse)geomManager.create(Geometry.TYPES.ELLIPSE, geometry.getGeometryType().getSubType()); |
|
| 315 |
Ellipse auxEllipse = (Ellipse) geomManager.create(Geometry.TYPES.ELLIPSE, geometry.getGeometryType().getSubType());
|
|
| 283 | 316 |
auxEllipse.setPoints(ellipse.getAxis1Start(), ellipse.getAxis1End(), ellipse.getAxis2Dist()); |
| 284 |
if(auxEllipse.contains(point)){
|
|
| 317 |
if (auxEllipse.contains(point)) {
|
|
| 285 | 318 |
return -minDistance; |
| 286 | 319 |
} |
| 287 | 320 |
return minDistance; |
| 288 | 321 |
} |
| 289 |
if(geometry instanceof Ellipse){
|
|
| 290 |
Ellipse ellipse = (Ellipse)geometry; |
|
| 291 |
PeriEllipse auxPeriEllipse = (PeriEllipse)geomManager.create(Geometry.TYPES.PERIELLIPSE, geometry.getGeometryType().getSubType()); |
|
| 322 |
if (geometry instanceof Ellipse) {
|
|
| 323 |
Ellipse ellipse = (Ellipse) geometry;
|
|
| 324 |
PeriEllipse auxPeriEllipse = (PeriEllipse) geomManager.create(Geometry.TYPES.PERIELLIPSE, geometry.getGeometryType().getSubType());
|
|
| 292 | 325 |
auxPeriEllipse.setPoints(ellipse.getAxis1Start(), ellipse.getAxis1End(), ellipse.getAxis2Dist()); |
| 293 | 326 |
double distance = getDistance(auxPeriEllipse, point); |
| 294 |
// if(ellipse.contains(point)){
|
|
| 295 |
// return -distance; |
|
| 296 |
// } |
|
| 297 | 327 |
|
| 298 | 328 |
return distance; |
| 299 | 329 |
} |
| 300 | 330 |
|
| 301 |
if(geometry instanceof Spline || geometry instanceof FilledSpline ){
|
|
| 331 |
if (geometry instanceof Spline || geometry instanceof FilledSpline) {
|
|
| 302 | 332 |
return getDistance(geometry.toLines().getPrimitiveAt(0), point); |
| 303 | 333 |
} |
| 304 | 334 |
|
| 305 |
if(geometry instanceof Line){
|
|
| 306 |
Line line = (Line)geometry; |
|
| 335 |
if (geometry instanceof Line) {
|
|
| 336 |
Line line = (Line) geometry;
|
|
| 307 | 337 |
double minDistance = Double.POSITIVE_INFINITY; |
| 308 | 338 |
Geometry[] closestPoints = point.closestPoints(line); |
| 309 | 339 |
Point closestPoint = null; |
| 310 |
if (closestPoints!=null){
|
|
| 311 |
for (int i=0;i<closestPoints.length;i++){
|
|
| 312 |
Point p=(Point)closestPoints[i];
|
|
| 340 |
if (closestPoints != null) {
|
|
| 341 |
for (Geometry closestPoint1 : closestPoints) {
|
|
| 342 |
Point p = (Point) closestPoint1;
|
|
| 313 | 343 |
if (!point.equals(p)) {
|
| 314 | 344 |
double distance = p.distance(point); |
| 315 | 345 |
if (distance < minDistance) {
|
| ... | ... | |
| 319 | 349 |
} |
| 320 | 350 |
} |
| 321 | 351 |
} |
| 322 |
if(closestPoint != null){
|
|
| 323 |
for(int i=0; i<line.getNumVertices()-1; i++){
|
|
| 352 |
if (closestPoint != null) {
|
|
| 353 |
for (int i = 0; i < line.getNumVertices() - 1; i++) {
|
|
| 324 | 354 |
Line segment = (Line) geomManager.create(Geometry.TYPES.LINE, geometry.getGeometryType().getSubType()); |
| 325 | 355 |
segment.addVertex(line.getVertex(i)); |
| 326 |
segment.addVertex(line.getVertex(i+1));
|
|
| 327 |
if(segment.isWithinDistance(closestPoint, PRECISION)){
|
|
| 328 |
if(line.getVertex(0).equals(line.getVertex(line.getNumVertices()-1))){ //isClosed
|
|
| 329 |
if(line.toPolygons().contains(point)){
|
|
| 356 |
segment.addVertex(line.getVertex(i + 1));
|
|
| 357 |
if (segment.isWithinDistance(closestPoint, PRECISION)) {
|
|
| 358 |
if (line.getVertex(0).equals(line.getVertex(line.getNumVertices() - 1))) { //isClosed
|
|
| 359 |
if (line.toPolygons().contains(point)) {
|
|
| 330 | 360 |
return -minDistance; |
| 331 |
};
|
|
| 361 |
} |
|
| 332 | 362 |
return minDistance; |
| 333 | 363 |
} else {
|
| 334 | 364 |
return getDirectedDistance(closestPoint, point, segment); |
| ... | ... | |
| 338 | 368 |
} |
| 339 | 369 |
} |
| 340 | 370 |
|
| 341 |
if(geometry instanceof Polygon){
|
|
| 342 |
Polygon polygon = (Polygon)geometry; |
|
| 343 |
if(!polygon.contains(point)){
|
|
| 371 |
if (geometry instanceof Polygon) {
|
|
| 372 |
Polygon polygon = (Polygon) geometry;
|
|
| 373 |
if (!polygon.contains(point)) {
|
|
| 344 | 374 |
double minDistance = Double.POSITIVE_INFINITY; |
| 345 | 375 |
Geometry[] closestPoints = point.closestPoints(polygon); |
| 346 | 376 |
Point closestPoint = null; |
| 347 |
if (closestPoints!=null){
|
|
| 348 |
for (int i=0;i<closestPoints.length;i++){
|
|
| 349 |
Point p=(Point)closestPoints[i];
|
|
| 377 |
if (closestPoints != null) {
|
|
| 378 |
for (Geometry closestPoint1 : closestPoints) {
|
|
| 379 |
Point p = (Point) closestPoint1;
|
|
| 350 | 380 |
if (!point.equals(p)) {
|
| 351 | 381 |
double distance = p.distance(point); |
| 352 | 382 |
if (distance < minDistance) {
|
| ... | ... | |
| 356 | 386 |
} |
| 357 | 387 |
} |
| 358 | 388 |
} |
| 359 |
if(closestPoint != null){
|
|
| 389 |
if (closestPoint != null) {
|
|
| 360 | 390 |
return closestPoint.distance(point); |
| 361 | 391 |
} |
| 362 | 392 |
} else {
|
| 363 | 393 |
Line auxLine = (Line) polygon.toLines().getPrimitiveAt(0); |
| 364 |
if(auxLine!=null){
|
|
| 394 |
if (auxLine != null) {
|
|
| 365 | 395 |
return getDistance(auxLine, point); |
| 366 | 396 |
} |
| 367 | 397 |
} |
| 368 | 398 |
} |
| 369 | 399 |
|
| 370 |
if(geometry instanceof Aggregate){
|
|
| 400 |
if (geometry instanceof Aggregate) {
|
|
| 371 | 401 |
double minDistance = Double.POSITIVE_INFINITY; |
| 372 |
Aggregate aggregate2 = (Aggregate)geometry; |
|
| 373 |
for(int i=0; i<aggregate2.getPrimitivesNumber(); i++){
|
|
| 374 |
double distance = getDistance(aggregate2.getPrimitiveAt(i),point); |
|
| 375 |
if(distance<minDistance){
|
|
| 402 |
Aggregate aggregate2 = (Aggregate) geometry;
|
|
| 403 |
for (int i = 0; i < aggregate2.getPrimitivesNumber(); i++) {
|
|
| 404 |
double distance = getDistance(aggregate2.getPrimitiveAt(i), point);
|
|
| 405 |
if (distance < minDistance) {
|
|
| 376 | 406 |
minDistance = distance; |
| 377 | 407 |
} |
| 378 | 408 |
} |
| ... | ... | |
| 381 | 411 |
return 0.0; |
| 382 | 412 |
} |
| 383 | 413 |
|
| 414 |
@Override |
|
| 384 | 415 |
public void stop() {
|
| 385 | 416 |
values.clear(); |
| 386 | 417 |
} |
| 387 | 418 |
|
| 388 | 419 |
private void validateAndInsertValue(EditingServiceParameter param, |
| 389 |
Object value) throws InvalidEntryException {
|
|
| 420 |
Object value) throws InvalidEntryException {
|
|
| 421 |
I18nManager i18nManager = ToolsLocator.getI18nManager(); |
|
| 422 |
|
|
| 390 | 423 |
if (param == selectionParameter) {
|
| 391 | 424 |
if (value instanceof FeatureSelection) {
|
| 392 | 425 |
values.put(param, value); |
| 393 |
return; |
|
| 394 | 426 |
} |
| 395 | 427 |
} else if (param == offsetParameter) {
|
| 396 | 428 |
if (value instanceof Point) {
|
| 397 | 429 |
try {
|
| 398 |
values.put(param, getMinDistance((FeatureSelection) values.get(selectionParameter), (Point) value)); |
|
| 430 |
Double distance = getMinDistance((FeatureSelection) values.get(selectionParameter), (Point) value); |
|
| 431 |
values.put(param, Math.abs(distance)); |
|
| 432 |
values.put(sideParameter, coerceSide(distance)); |
|
| 399 | 433 |
} catch (Exception e) {
|
| 400 | 434 |
throw new InvalidEntryException(e); |
| 401 | 435 |
} |
| 402 | 436 |
return; |
| 403 | 437 |
} |
| 404 | 438 |
if (value instanceof Double) {
|
| 405 |
values.put(param, value); |
|
| 439 |
Double distance = (Double) value; |
|
| 440 |
if (distance >= 0) {
|
|
| 441 |
values.put(param, value); |
|
| 442 |
} else {
|
|
| 443 |
values.put(param, Math.abs(distance)); |
|
| 444 |
values.put(sideParameter, coerceSide(distance)); |
|
| 445 |
} |
|
| 406 | 446 |
} |
| 447 |
} else if (param == sideParameter) {
|
|
| 448 |
if (value instanceof Point) {
|
|
| 449 |
try {
|
|
| 450 |
values.put(param, coerceSide(getMinDistance((FeatureSelection) values.get(selectionParameter), (Point) value))); |
|
| 451 |
} catch (Exception e) {
|
|
| 452 |
throw new InvalidEntryException(e); |
|
| 453 |
} |
|
| 454 |
return; |
|
| 455 |
} |
|
| 456 |
if (value instanceof String) {
|
|
| 457 |
values.put(param, coerceSide(value)); |
|
| 458 |
} |
|
| 407 | 459 |
} else if (param == deleteOriginalGeometriesParameter) {
|
| 408 | 460 |
if (value instanceof String) {
|
| 409 | 461 |
if (((String) value).trim().equalsIgnoreCase( |
| 410 |
i18nManager.getTranslation("short_yes"))) {
|
|
| 462 |
i18nManager.getTranslation("short_yes"))) {
|
|
| 411 | 463 |
deleteOriginalGeometries = true; |
| 412 | 464 |
} else if (((String) value).trim().equalsIgnoreCase( |
| 413 |
i18nManager.getTranslation("short_no"))) {
|
|
| 465 |
i18nManager.getTranslation("short_no"))) {
|
|
| 414 | 466 |
deleteOriginalGeometries = false; |
| 415 | 467 |
} else {
|
| 416 | 468 |
throw new InvalidEntryException(null); |
| ... | ... | |
| 421 | 473 |
|
| 422 | 474 |
} |
| 423 | 475 |
|
| 476 |
private String coerceSide(Object value) throws InvalidEntryException {
|
|
| 477 |
|
|
| 478 |
if (value instanceof Double) {
|
|
| 479 |
return (Double) value >= 0 ? LEFT : RIGHT; |
|
| 480 |
} |
|
| 481 |
if (value instanceof String) {
|
|
| 482 |
Double signum = getSideSignum((String) value); |
|
| 483 |
if (signum != null) {
|
|
| 484 |
return signum >= 0 ? LEFT : RIGHT; |
|
| 485 |
} |
|
| 486 |
} |
|
| 487 |
throw new InvalidEntryException(null); |
|
| 488 |
} |
|
| 489 |
|
|
| 490 |
private Double getSideSignum(String side) {
|
|
| 491 |
I18nManager i18nManager = ToolsLocator.getI18nManager(); |
|
| 492 |
String sideTrim = side.trim(); |
|
| 493 |
if (StringUtils.equalsIgnoreCase(sideTrim, LEFT) |
|
| 494 |
|| StringUtils.startsWithIgnoreCase(i18nManager.getTranslation(LEFT), sideTrim)) {
|
|
| 495 |
return 1.0; |
|
| 496 |
} else if (StringUtils.equalsIgnoreCase(sideTrim, RIGHT) |
|
| 497 |
|| StringUtils.startsWithIgnoreCase(i18nManager.getTranslation(RIGHT), sideTrim)) {
|
|
| 498 |
return -1.0; |
|
| 499 |
} |
|
| 500 |
return null; |
|
| 501 |
} |
|
| 502 |
|
|
| 503 |
@Override |
|
| 424 | 504 |
public List<EditingServiceParameter> getParameters() {
|
| 425 |
List<EditingServiceParameter> list =
|
|
| 426 |
new ArrayList<EditingServiceParameter>();
|
|
| 505 |
List<EditingServiceParameter> list |
|
| 506 |
= new ArrayList<>();
|
|
| 427 | 507 |
list.add(selectionParameter); |
| 428 | 508 |
list.add(offsetParameter); |
| 509 |
list.add(sideParameter); |
|
| 429 | 510 |
return list; |
| 430 | 511 |
} |
| 431 | 512 |
|
| 513 |
@Override |
|
| 432 | 514 |
public void setValue(Object value) throws InvalidEntryException {
|
| 433 | 515 |
EditingServiceParameter param = next(); |
| 434 | 516 |
validateAndInsertValue(param, value); |
| 435 | 517 |
} |
| 436 | 518 |
|
| 519 |
@Override |
|
| 437 | 520 |
public void finishAndStore() throws FinishServiceException {
|
| 438 | 521 |
|
| 439 |
FeatureSelection selected =
|
|
| 440 |
(FeatureSelection) values.get(selectionParameter); |
|
| 522 |
FeatureSelection selected |
|
| 523 |
= (FeatureSelection) values.get(selectionParameter);
|
|
| 441 | 524 |
try {
|
| 442 | 525 |
if (!selected.isEmpty()) {
|
| 443 |
double distance = (Double) values.get(offsetParameter); |
|
| 444 |
DisposableIterator it; |
|
| 445 |
it = selected.fastIterator(); |
|
| 526 |
double side = 1.0; |
|
| 527 |
Object sideValue = values.get(sideParameter); |
|
| 528 |
if (sideValue != null) {
|
|
| 529 |
if (sideValue instanceof String) {
|
|
| 530 |
Double signum = getSideSignum((String) sideValue); |
|
| 531 |
side = signum != null ? signum : null; |
|
| 532 |
} |
|
| 533 |
} |
|
| 534 |
double distance = ((Double) values.get(offsetParameter)) * side; |
|
| 535 |
DisposableIterator it; |
|
| 536 |
it = selected.fastIterator(); |
|
| 446 | 537 |
|
| 447 |
while (it.hasNext()) {
|
|
| 448 |
Feature feature = (Feature) it.next(); |
|
| 449 |
Geometry geom; |
|
| 450 |
try {
|
|
| 451 |
geom = feature.getDefaultGeometry().offset(distance); |
|
| 452 |
} catch (GeometryOperationNotSupportedException e) {
|
|
| 453 |
throw new FinishServiceException(e); |
|
| 454 |
} catch (GeometryOperationException e) {
|
|
| 455 |
throw new FinishServiceException(e); |
|
| 456 |
} |
|
| 538 |
while (it.hasNext()) {
|
|
| 539 |
Feature feature = (Feature) it.next(); |
|
| 540 |
Geometry geom; |
|
| 541 |
try {
|
|
| 542 |
geom = feature.getDefaultGeometry().offset(distance); |
|
| 543 |
} catch (GeometryOperationNotSupportedException | GeometryOperationException e) {
|
|
| 544 |
throw new FinishServiceException(e); |
|
| 545 |
} |
|
| 457 | 546 |
|
| 458 |
if (this.deleteOriginalGeometries) {
|
|
| 459 |
// Se sustituye la geometr?a original por la
|
|
| 460 |
// calculada
|
|
| 461 |
EditableFeature editableFeature =
|
|
| 462 |
feature.getEditable(); |
|
| 463 |
editableFeature.setDefaultGeometry(geom);
|
|
| 464 |
((EditingProviderServices) getProviderServices())
|
|
| 547 |
if (this.deleteOriginalGeometries) {
|
|
| 548 |
// Se sustituye la geometr?a original por la |
|
| 549 |
// calculada |
|
| 550 |
EditableFeature editableFeature
|
|
| 551 |
= feature.getEditable();
|
|
| 552 |
editableFeature.setDefaultGeometry(geom); |
|
| 553 |
((EditingProviderServices) getProviderServices()) |
|
| 465 | 554 |
.updateFeatureInFeatureStore(editableFeature, |
| 466 |
featureStore); |
|
| 467 |
} else {
|
|
| 468 |
// Se crea una feature nueva copiando los valores de
|
|
| 469 |
// la feature original excepto aquellos que sean PK
|
|
| 470 |
EditingProviderServices editingProviderServices =
|
|
| 471 |
(EditingProviderServices) getProviderServices(); |
|
| 472 |
EditableFeature editableFeature =
|
|
| 473 |
editingProviderServices |
|
| 474 |
.getFeatureCopyWithoutPK(featureStore, |
|
| 475 |
feature); |
|
| 476 |
editableFeature.setDefaultGeometry(geom);
|
|
| 477 |
editingProviderServices
|
|
| 555 |
featureStore);
|
|
| 556 |
} else {
|
|
| 557 |
// Se crea una feature nueva copiando los valores de |
|
| 558 |
// la feature original excepto aquellos que sean PK |
|
| 559 |
EditingProviderServices editingProviderServices
|
|
| 560 |
= (EditingProviderServices) getProviderServices();
|
|
| 561 |
EditableFeature editableFeature
|
|
| 562 |
= editingProviderServices
|
|
| 563 |
.getFeatureCopyWithoutPK(featureStore,
|
|
| 564 |
feature);
|
|
| 565 |
editableFeature.setDefaultGeometry(geom); |
|
| 566 |
editingProviderServices |
|
| 478 | 567 |
.insertFeatureIntoFeatureStore(editableFeature, |
| 479 |
featureStore); |
|
| 480 |
}
|
|
| 568 |
featureStore);
|
|
| 569 |
} |
|
| 481 | 570 |
|
| 482 |
} |
|
| 483 |
it.dispose(); |
|
| 484 |
featureStore.getFeatureSelection().deselectAll(); |
|
| 485 | 571 |
} |
| 572 |
it.dispose(); |
|
| 573 |
featureStore.getFeatureSelection().deselectAll(); |
|
| 574 |
} |
|
| 486 | 575 |
} catch (DataException e) {
|
| 487 | 576 |
throw new FinishServiceException(e); |
| 488 | 577 |
} |
| 489 | 578 |
} |
| 490 | 579 |
|
| 491 | 580 |
private Double getDirectedDistance(Point pointInLine, Point distancePoint, Line line) |
| 492 |
throws GeometryOperationNotSupportedException, GeometryOperationException{
|
|
| 493 |
Double distance=distancePoint.distance(pointInLine);
|
|
| 494 |
EditingProviderServices editingProviderServices =
|
|
| 495 |
(EditingProviderServices) getProviderServices(); |
|
| 581 |
throws GeometryOperationNotSupportedException, GeometryOperationException {
|
|
| 582 |
Double distance = distancePoint.distance(pointInLine);
|
|
| 583 |
EditingProviderServices editingProviderServices |
|
| 584 |
= (EditingProviderServices) getProviderServices();
|
|
| 496 | 585 |
Double angle = editingProviderServices.getAngle(pointInLine, distancePoint); |
| 497 | 586 |
double angleLine = editingProviderServices.getAngle(line.getVertex(0), line.getVertex(1)); |
| 498 | 587 |
|
| 499 |
Double angleDifference=angle - angleLine;
|
|
| 500 |
if ( angleDifference<0 ){
|
|
| 501 |
angleDifference+=2*Math.PI;
|
|
| 588 |
Double angleDifference = angle - angleLine;
|
|
| 589 |
if (angleDifference < 0) {
|
|
| 590 |
angleDifference += 2 * Math.PI;
|
|
| 502 | 591 |
} |
| 503 |
if (angleDifference > Math.PI ) {
|
|
| 592 |
if (angleDifference > Math.PI) {
|
|
| 504 | 593 |
distance = -distance; |
| 505 | 594 |
} |
| 506 | 595 |
return distance; |
| 507 | 596 |
} |
| 508 | 597 |
|
| 598 |
@Override |
|
| 509 | 599 |
public Geometry finish() throws FinishServiceException {
|
| 510 | 600 |
return null; |
| 511 | 601 |
} |
| 512 | 602 |
|
| 603 |
@Override |
|
| 513 | 604 |
public void start() throws StartServiceException {
|
| 514 |
this.values = new HashMap<EditingServiceParameter, Object>();
|
|
| 605 |
this.values = new HashMap<>(); |
|
| 515 | 606 |
FeatureSelection selected = null; |
| 516 | 607 |
if (featureStore != null) {
|
| 517 | 608 |
try {
|
| 518 |
selected =
|
|
| 519 |
(FeatureSelection) featureStore.getFeatureSelection() |
|
| 520 |
.clone(); |
|
| 609 |
selected |
|
| 610 |
= (FeatureSelection) featureStore.getFeatureSelection()
|
|
| 611 |
.clone();
|
|
| 521 | 612 |
} catch (DataException e) {
|
| 522 | 613 |
throw new StartServiceException(e); |
| 523 | 614 |
} catch (CloneNotSupportedException e) {
|
| ... | ... | |
| 529 | 620 |
} |
| 530 | 621 |
} |
| 531 | 622 |
|
| 623 |
@Override |
|
| 532 | 624 |
public String getName() {
|
| 533 | 625 |
return OffsetEditingProviderFactory.PROVIDER_NAME; |
| 534 | 626 |
} |
| 535 |
} |
|
| 627 |
} |
|
Also available in: Unified diff