Revision 492 org.gvsig.gpe/library/trunk/org.gvsig.gpe/org.gvsig.gpe.app/org.gvsig.gpe.app.mainplugin/src/main/java/org/gvsig/fmap/dal/store/gpe/handlers/FmapContentHandler.java
FmapContentHandler.java | ||
---|---|---|
1 |
/* gvSIG. Sistema de Informaci?n Geogr?fica de la Generalitat Valenciana |
|
2 |
* |
|
3 |
* Copyright (C) 2004 IVER T.I. and Generalitat Valenciana. |
|
4 |
* |
|
5 |
* This program is free software; you can redistribute it and/or |
|
6 |
* modify it under the terms of the GNU General Public License |
|
7 |
* as published by the Free Software Foundation; either version 2 |
|
8 |
* of the License, or (at your option) any later version. |
|
9 |
* |
|
10 |
* This program is distributed in the hope that it will be useful, |
|
11 |
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
|
12 |
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
|
13 |
* GNU General Public License for more details. |
|
14 |
* |
|
15 |
* You should have received a copy of the GNU General Public License |
|
16 |
* along with this program; if not, write to the Free Software |
|
17 |
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,USA. |
|
18 |
*/ |
|
19 |
|
|
1 | 20 |
package org.gvsig.fmap.dal.store.gpe.handlers; |
2 | 21 |
|
3 | 22 |
import java.io.File; |
... | ... | |
26 | 45 |
import org.gvsig.fmap.geom.GeometryLocator; |
27 | 46 |
import org.gvsig.fmap.geom.GeometryManager; |
28 | 47 |
import org.gvsig.fmap.geom.aggregate.MultiCurve; |
48 |
import org.gvsig.fmap.geom.aggregate.MultiLine; |
|
29 | 49 |
import org.gvsig.fmap.geom.aggregate.MultiPoint; |
30 |
import org.gvsig.fmap.geom.aggregate.MultiPrimitive; |
|
31 |
import org.gvsig.fmap.geom.aggregate.MultiSurface; |
|
50 |
import org.gvsig.fmap.geom.aggregate.MultiPolygon; |
|
32 | 51 |
import org.gvsig.fmap.geom.exception.CreateEnvelopeException; |
33 | 52 |
import org.gvsig.fmap.geom.exception.CreateGeometryException; |
34 | 53 |
import org.gvsig.fmap.geom.primitive.Curve; |
35 | 54 |
import org.gvsig.fmap.geom.primitive.Envelope; |
36 |
import org.gvsig.fmap.geom.primitive.GeneralPathX;
|
|
55 |
import org.gvsig.fmap.geom.primitive.Line;
|
|
37 | 56 |
import org.gvsig.fmap.geom.primitive.Point; |
38 |
import org.gvsig.fmap.geom.primitive.Primitive;
|
|
39 |
import org.gvsig.fmap.geom.primitive.Surface;
|
|
57 |
import org.gvsig.fmap.geom.primitive.Polygon;
|
|
58 |
import org.gvsig.fmap.geom.primitive.Ring;
|
|
40 | 59 |
import org.gvsig.gpe.lib.api.parser.IAttributesIterator; |
41 | 60 |
import org.gvsig.gpe.lib.api.parser.ICoordinateIterator; |
42 | 61 |
import org.gvsig.gpe.lib.api.parser.IGPEErrorHandler; |
... | ... | |
44 | 63 |
import org.jfree.util.Log; |
45 | 64 |
import org.slf4j.Logger; |
46 | 65 |
import org.slf4j.LoggerFactory; |
47 |
/* gvSIG. Sistema de Informaci?n Geogr?fica de la Generalitat Valenciana |
|
48 |
* |
|
49 |
* Copyright (C) 2004 IVER T.I. and Generalitat Valenciana. |
|
50 |
* |
|
51 |
* This program is free software; you can redistribute it and/or |
|
52 |
* modify it under the terms of the GNU General Public License |
|
53 |
* as published by the Free Software Foundation; either version 2 |
|
54 |
* of the License, or (at your option) any later version. |
|
55 |
* |
|
56 |
* This program is distributed in the hope that it will be useful, |
|
57 |
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
|
58 |
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
|
59 |
* GNU General Public License for more details. |
|
60 |
* |
|
61 |
* You should have received a copy of the GNU General Public License |
|
62 |
* along with this program; if not, write to the Free Software |
|
63 |
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,USA. |
|
64 |
*/ |
|
65 | 66 |
|
67 |
|
|
68 |
|
|
66 | 69 |
public class FmapContentHandler extends GPEContentHandler { |
67 | 70 |
private static final Logger LOG = LoggerFactory.getLogger(FmapContentHandler.class); |
68 | 71 |
|
... | ... | |
87 | 90 |
this.file = file; |
88 | 91 |
this.srs = srs; |
89 | 92 |
this.geometryType = geometryType; |
90 |
}
|
|
91 |
|
|
93 |
} |
|
94 |
|
|
92 | 95 |
public FmapContentHandler(IGPEErrorHandler errorHandler, FeatureStoreProviderServices store, |
93 | 96 |
GPEStoreProvider storeProvider, File file, IProjection srs, int geometryType, |
94 | 97 |
boolean useAxisOrderYX) { |
... | ... | |
228 | 231 |
return createCurve(coords); |
229 | 232 |
} |
230 | 233 |
|
231 |
private Curve createCurve(ICoordinateIterator coords){
|
|
232 |
GeneralPathX gp = createGeneralPathX(coords); |
|
234 |
private Line createCurve(ICoordinateIterator coords){
|
|
235 |
// GeneralPathX gp = createGeneralPathX(coords);
|
|
233 | 236 |
try { |
234 |
Curve curve = null;
|
|
237 |
Line curve = null;
|
|
235 | 238 |
if (coords == null || coords.getDimension() == 2){ |
236 |
curve = (Curve) geomManager.create(TYPES.CURVE, SUBTYPES.GEOM2D);
|
|
239 |
curve = (Line) geomManager.create(TYPES.LINE, SUBTYPES.GEOM2D);
|
|
237 | 240 |
}else if (coords.getDimension() == 3){ |
238 |
curve = (Curve) geomManager.create(TYPES.CURVE, SUBTYPES.GEOM3D);
|
|
241 |
curve = (Line) geomManager.create(TYPES.LINE, SUBTYPES.GEOM3D);
|
|
239 | 242 |
} |
240 |
curve.setGeneralPath(gp); |
|
243 |
while (coords.hasNext()){ |
|
244 |
Point point=createPoint(coords); |
|
245 |
curve.addVertex(point); |
|
246 |
} |
|
247 |
// curve.setGeneralPath(gp); |
|
241 | 248 |
return curve; |
242 | 249 |
} catch (CreateGeometryException e) { |
243 | 250 |
getErrorHandler().addError(e); |
244 |
} |
|
245 |
return null; |
|
246 |
} |
|
247 |
|
|
248 |
private GeneralPathX createGeneralPathX(ICoordinateIterator coords){ |
|
249 |
GeneralPathX gp = new GeneralPathX(); |
|
250 |
if (coords == null){ |
|
251 |
return gp; |
|
252 |
} |
|
253 |
double[] buffer = new double[coords.getDimension()]; |
|
254 |
try { |
|
255 |
if (coords.hasNext()){ |
|
256 |
coords.next(buffer); |
|
257 |
if( this.useAxisOrderYX ) { |
|
258 |
gp.moveTo(buffer[1], buffer[0]); |
|
259 |
} else { |
|
260 |
gp.moveTo(buffer[0], buffer[1]); |
|
261 |
} |
|
262 |
} |
|
263 |
while(coords.hasNext()){ |
|
264 |
coords.next(buffer); |
|
265 |
if( this.useAxisOrderYX ) { |
|
266 |
gp.lineTo(buffer[1], buffer[0]); |
|
267 |
} else { |
|
268 |
gp.lineTo(buffer[0], buffer[1]); |
|
269 |
} |
|
270 |
} |
|
271 | 251 |
} catch (IOException e) { |
272 | 252 |
getErrorHandler().addError(e); |
273 | 253 |
} |
274 |
return gp;
|
|
254 |
return null;
|
|
275 | 255 |
} |
276 | 256 |
|
257 |
// private GeneralPathX createGeneralPathX(ICoordinateIterator coords){ |
|
258 |
// GeneralPathX gp = new GeneralPathX(); |
|
259 |
// if (coords == null){ |
|
260 |
// return gp; |
|
261 |
// } |
|
262 |
// double[] buffer = new double[coords.getDimension()]; |
|
263 |
// try { |
|
264 |
// if (coords.hasNext()){ |
|
265 |
// coords.next(buffer); |
|
266 |
// if( this.useAxisOrderYX ) { |
|
267 |
// gp.moveTo(buffer[1], buffer[0]); |
|
268 |
// } else { |
|
269 |
// gp.moveTo(buffer[0], buffer[1]); |
|
270 |
// } |
|
271 |
// } |
|
272 |
// while(coords.hasNext()){ |
|
273 |
// coords.next(buffer); |
|
274 |
// if( this.useAxisOrderYX ) { |
|
275 |
// gp.lineTo(buffer[1], buffer[0]); |
|
276 |
// } else { |
|
277 |
// gp.lineTo(buffer[0], buffer[1]); |
|
278 |
// } |
|
279 |
// } |
|
280 |
// } catch (IOException e) { |
|
281 |
// getErrorHandler().addError(e); |
|
282 |
// } |
|
283 |
// return gp; |
|
284 |
// } |
|
285 |
|
|
277 | 286 |
/* (non-Javadoc) |
278 | 287 |
* @see org.gvsig.gpe.parser.GPEContentHandler#startPolygon(java.lang.String, org.gvsig.gpe.parser.ICoordinateIterator, java.lang.String) |
279 | 288 |
*/ |
280 | 289 |
|
281 | 290 |
public Object startPolygon(String id, ICoordinateIterator coords, String srs) { |
282 |
return createSurface(coords);
|
|
291 |
return createPolygon(coords);
|
|
283 | 292 |
} |
284 | 293 |
|
285 |
private Surface createSurface(ICoordinateIterator coords){
|
|
286 |
GeneralPathX gp = createGeneralPathX(coords); |
|
294 |
private Polygon createPolygon(ICoordinateIterator coords){
|
|
295 |
// GeneralPathX gp = createGeneralPathX(coords);
|
|
287 | 296 |
try { |
288 |
Surface surface = null;
|
|
297 |
Polygon polygon = null;
|
|
289 | 298 |
if (coords.getDimension() == 2){ |
290 |
surface = (Surface) geomManager.create(TYPES.SURFACE, SUBTYPES.GEOM2D);
|
|
299 |
polygon = (Polygon) geomManager.create(TYPES.POLYGON, SUBTYPES.GEOM2D);
|
|
291 | 300 |
}else if (coords.getDimension() == 3){ |
292 |
surface = (Surface) geomManager.create(TYPES.SURFACE, SUBTYPES.GEOM3D);
|
|
301 |
polygon = (Polygon) geomManager.create(TYPES.POLYGON, SUBTYPES.GEOM3D);
|
|
293 | 302 |
} |
294 |
surface.setGeneralPath(gp); |
|
295 |
return surface; |
|
303 |
//surface.setGeneralPath(gp); |
|
304 |
while (coords.hasNext()){ |
|
305 |
Point point=createPoint(coords); |
|
306 |
polygon.addVertex(point); |
|
307 |
} |
|
308 |
if (!polygon.getVertex(0).equals(polygon.getVertex(polygon.getNumVertices()-1))){ |
|
309 |
polygon.addVertex(polygon.getVertex(0)); |
|
310 |
} |
|
311 |
|
|
312 |
return polygon; |
|
296 | 313 |
} catch (CreateGeometryException e) { |
297 | 314 |
getErrorHandler().addError(e); |
315 |
} catch (IOException e) { |
|
316 |
getErrorHandler().addError(e); |
|
298 | 317 |
} |
299 | 318 |
return null; |
300 | 319 |
} |
... | ... | |
305 | 324 |
*/ |
306 | 325 |
public Object startInnerPolygon(String id, ICoordinateIterator coords, |
307 | 326 |
String srs) { |
308 |
return createSurface(coords);
|
|
327 |
return createPolygon(coords);
|
|
309 | 328 |
} |
310 | 329 |
|
311 | 330 |
/* |
... | ... | |
313 | 332 |
* @see org.gvsig.gpe.IGPEContentHandler#addGeometryToFeature(java.lang.Object, java.lang.Object) |
314 | 333 |
*/ |
315 | 334 |
public void addGeometryToFeature(Object geometry, Object feature) { |
316 |
|
|
335 |
|
|
317 | 336 |
/* |
318 | 337 |
* Two geometries (possibly of different type) in the same feature |
319 | 338 |
* Instead of overwriting we will preserve the first that arrives. |
320 | 339 |
* Alternative: aggregate, but then gvSIG would have issues to |
321 |
* draw? or export?
|
|
340 |
* draw? or export? |
|
322 | 341 |
*/ |
323 | 342 |
GPEFeature gpe_feat = (GPEFeature) feature; |
324 | 343 |
Geometry geom = gpe_feat.getGeometry(); |
325 | 344 |
if (geom == null || |
326 | 345 |
geom.getGeometryType().getType() == Geometry.TYPES.NULL) { |
327 |
|
|
346 |
|
|
328 | 347 |
gpe_feat.setGeometry((Geometry)geometry); |
329 | 348 |
} |
330 | 349 |
} |
... | ... | |
389 | 408 |
FeatureProvider data = new DefaultFeatureProvider(featureType.getNotEditableCopy(), storeProvider.createNewOID()); |
390 | 409 |
Map elements = gpefeature.getelements(); |
391 | 410 |
Iterator keys = elements.keySet().iterator(); |
392 |
String gid = gpefeature.getId();
|
|
393 |
data.setOID(gid);
|
|
411 |
String gid = gpefeature.getId(); |
|
412 |
data.setOID(gid); |
|
394 | 413 |
while (keys.hasNext()){ |
395 | 414 |
String elementName = (String)keys.next(); |
396 | 415 |
if (featureType.getIndex(elementName) != -1) { |
... | ... | |
398 | 417 |
* If attribute exists, set its value |
399 | 418 |
* (if a field description was not properly parsed in the |
400 | 419 |
* feature type description (previous http request) then |
401 |
* perhaps it's not available in featureType)
|
|
420 |
* perhaps it's not available in featureType) |
|
402 | 421 |
*/ |
403 | 422 |
data.set(elementName, ((GPEElement)elements.get(elementName)).getValue()); |
404 | 423 |
} |
... | ... | |
411 | 430 |
|
412 | 431 |
private void createFeatureType(GPEFeature gpefeature){ |
413 | 432 |
featureType = store.createFeatureType(); |
414 |
|
|
433 |
|
|
415 | 434 |
//Adding the Geometry field |
416 | 435 |
EditableFeatureAttributeDescriptor attributeDescriptor = featureType.add("the_geom", DataTypes.GEOMETRY).setGeometryType(geometryType); |
417 | 436 |
attributeDescriptor.setGeometrySubType(SUBTYPES.GEOM2D); |
418 | 437 |
attributeDescriptor.setSRS(srs); |
419 | 438 |
featureType.setDefaultGeometryAttributeName("the_geom"); |
420 |
|
|
439 |
|
|
421 | 440 |
//Adding the ID |
422 | 441 |
EditableFeatureAttributeDescriptor ed = featureType.add("gid", DataTypes.LONG); |
423 | 442 |
ed.setSize(10); |
... | ... | |
521 | 540 |
IAttributesIterator attributes, Object layer){ |
522 | 541 |
String sId; |
523 | 542 |
if (id == null){ |
524 |
sId = new String(new Long(featureId).toString());
|
|
543 |
sId = new String(new Long(featureId).toString()); |
|
525 | 544 |
}else{ |
526 | 545 |
sId = id; |
527 | 546 |
} |
... | ... | |
567 | 586 |
*/ |
568 | 587 |
public Object startLinearRing(String id, ICoordinateIterator coords, |
569 | 588 |
String srs) { |
570 |
return createSurface(coords);
|
|
589 |
return createPolygon(coords);
|
|
571 | 590 |
} |
572 | 591 |
|
573 | 592 |
/* |
... | ... | |
585 | 604 |
|
586 | 605 |
/* |
587 | 606 |
* (non-Javadoc) |
607 |
* @see org.gvsig.gpe.IGPEContentHandler#startMultiPoint(java.lang.String, java.lang.String) |
|
608 |
*/ |
|
609 |
public Object startMultiPoint(String id, String srs) { |
|
610 |
try { |
|
611 |
return geomManager.create(TYPES.MULTIPOINT, Geometry.SUBTYPES.GEOM2D); |
|
612 |
} catch (CreateGeometryException e) { |
|
613 |
getErrorHandler().addError(e); |
|
614 |
} |
|
615 |
return null; |
|
616 |
} |
|
617 |
|
|
618 |
/* |
|
619 |
* (non-Javadoc) |
|
588 | 620 |
* @see org.gvsig.gpe.IGPEContentHandler#addPointToMultiPoint(java.lang.Object, java.lang.Object) |
589 | 621 |
*/ |
590 | 622 |
public void addPointToMultiPoint(Object point, Object multiPoint) { |
591 |
((MultiPoint)multiPoint).addPoint((Point)point); |
|
623 |
if (point instanceof Point){ |
|
624 |
Point gPoint=(Point)point; |
|
625 |
if (gPoint.getGeometryType().isSubTypeOf( Geometry.SUBTYPES.GEOM3D)){ |
|
626 |
try { |
|
627 |
Point point2D=(Point)geomManager.create(TYPES.POINT, Geometry.SUBTYPES.GEOM2D); |
|
628 |
point2D.setX(gPoint.getX()); |
|
629 |
point2D.setY(gPoint.getY()); |
|
630 |
((MultiPoint)multiPoint).addPoint(point2D); |
|
631 |
} catch (CreateGeometryException e) { |
|
632 |
getErrorHandler().addError(e); |
|
633 |
} |
|
634 |
}else{ |
|
635 |
((MultiPoint)multiPoint).addPoint((Point)point); |
|
636 |
} |
|
637 |
} |
|
592 | 638 |
} |
593 | 639 |
|
594 | 640 |
/* |
... | ... | |
598 | 644 |
public Object startMultiLineString(String id, String srs, int dimension) { |
599 | 645 |
super.startMultiLineString(id, srs); |
600 | 646 |
try { |
601 |
return geomManager.create(TYPES.MULTICURVE, getGeometrySubtype(dimension));
|
|
647 |
return geomManager.create(TYPES.MULTILINE, getGeometrySubtype(dimension));
|
|
602 | 648 |
} catch (CreateGeometryException e) { |
603 | 649 |
getErrorHandler().addError(e); |
604 | 650 |
} |
... | ... | |
607 | 653 |
|
608 | 654 |
/* |
609 | 655 |
* (non-Javadoc) |
656 |
* @see org.gvsig.gpe.IGPEContentHandler#startMultiLineString(java.lang.String, java.lang.String) |
|
657 |
*/ |
|
658 |
public Object startMultiLineString(String id, String srs) { |
|
659 |
return startMultiLineString (id, srs, Geometry.SUBTYPES.GEOM2D); |
|
660 |
} |
|
661 |
|
|
662 |
/* |
|
663 |
* (non-Javadoc) |
|
610 | 664 |
* @see org.gvsig.gpe.IGPEContentHandler#addLineStringToMultiLineString(java.lang.Object, java.lang.Object) |
611 | 665 |
*/ |
612 | 666 |
public void addLineStringToMultiLineString(Object lineString, Object multiLineString) { |
613 |
((MultiCurve)multiLineString).addCurve((Curve)lineString); |
|
667 |
if (lineString instanceof Line){ |
|
668 |
Line gLine=(Line)lineString; |
|
669 |
if (gLine.getGeometryType().isSubTypeOf( Geometry.SUBTYPES.GEOM3D)){ |
|
670 |
try { |
|
671 |
Line line2D=(Line)geomManager.create(TYPES.LINE, Geometry.SUBTYPES.GEOM2D); |
|
672 |
for(int i=0;i<gLine.getNumVertices();i++){ |
|
673 |
Point point2D=(Point)geomManager.create(TYPES.POINT, Geometry.SUBTYPES.GEOM2D); |
|
674 |
Point point3D=gLine.getVertex(i); |
|
675 |
point2D.setX(point3D.getX()); |
|
676 |
point2D.setY(point3D.getY()); |
|
677 |
line2D.addVertex(point2D); |
|
678 |
} |
|
679 |
((MultiLine)multiLineString).addPrimitive(line2D);; |
|
680 |
} catch (CreateGeometryException e) { |
|
681 |
getErrorHandler().addError(e); |
|
682 |
} |
|
683 |
}else{ |
|
684 |
((MultiLine)multiLineString).addPrimitive((Line)lineString); |
|
685 |
} |
|
686 |
} |
|
614 | 687 |
} |
615 | 688 |
|
616 | 689 |
/* |
... | ... | |
620 | 693 |
public Object startMultiPolygon(String id, String srs, int dimension) { |
621 | 694 |
super.startMultiPolygon(id, srs); |
622 | 695 |
try { |
623 |
return geomManager.create(TYPES.MULTISURFACE, getGeometrySubtype(dimension));
|
|
696 |
return geomManager.create(TYPES.MULTIPOLYGON, getGeometrySubtype(dimension));
|
|
624 | 697 |
} catch (CreateGeometryException e) { |
625 | 698 |
getErrorHandler().addError(e); |
626 | 699 |
} |
... | ... | |
629 | 702 |
|
630 | 703 |
/* |
631 | 704 |
* (non-Javadoc) |
705 |
* @see org.gvsig.gpe.IGPEContentHandler#startMultiPolygon(java.lang.String, java.lang.String) |
|
706 |
*/ |
|
707 |
public Object startMultiPolygon(String id, String srs) { |
|
708 |
return startMultiPolygon(id, srs, Geometry.SUBTYPES.GEOM2D); |
|
709 |
} |
|
710 |
|
|
711 |
/* |
|
712 |
* (non-Javadoc) |
|
632 | 713 |
* @see org.gvsig.gpe.IGPEContentHandler#addPolygonToMultiPolygon(java.lang.Object, java.lang.Object) |
633 | 714 |
*/ |
634 | 715 |
public void addPolygonToMultiPolygon(Object polygon, Object multiPolygon) { |
635 |
((MultiSurface)multiPolygon).addSurface((Surface)polygon); |
|
716 |
if (polygon instanceof Polygon){ |
|
717 |
Polygon gPolygon=(Polygon)polygon; |
|
718 |
if (gPolygon.getGeometryType().isSubTypeOf( Geometry.SUBTYPES.GEOM3D)){ |
|
719 |
try { |
|
720 |
Polygon polygon2D=(Polygon)geomManager.create(TYPES.POLYGON, Geometry.SUBTYPES.GEOM2D); |
|
721 |
for (int p=0;p<gPolygon.getNumVertices();p++){ |
|
722 |
Point point2D=(Point)geomManager.create(TYPES.POINT, Geometry.SUBTYPES.GEOM2D); |
|
723 |
Point point3D=gPolygon.getVertex(p); |
|
724 |
point2D.setX(point3D.getX()); |
|
725 |
point2D.setY(point3D.getY()); |
|
726 |
polygon2D.addVertex(point2D); |
|
727 |
} |
|
728 |
for (int r=0;r<gPolygon.getNumInteriorRings();r++){ |
|
729 |
Ring ring2D=(Ring)geomManager.create(TYPES.RING, Geometry.SUBTYPES.GEOM2D); |
|
730 |
Ring ring3D=gPolygon.getInteriorRing(r); |
|
731 |
for(int i=0;i<ring2D.getNumVertices();i++){ |
|
732 |
Point point2D=(Point)geomManager.create(TYPES.POINT, Geometry.SUBTYPES.GEOM2D); |
|
733 |
Point point3D=ring3D.getVertex(i); |
|
734 |
point2D.setX(point3D.getX()); |
|
735 |
point2D.setY(point3D.getY()); |
|
736 |
ring2D.addVertex(point2D); |
|
737 |
} |
|
738 |
polygon2D.addInteriorRing(ring2D); |
|
739 |
} |
|
740 |
((MultiPolygon)multiPolygon).addPrimitive(polygon2D); |
|
741 |
} catch (CreateGeometryException e) { |
|
742 |
getErrorHandler().addError(e); |
|
743 |
} |
|
744 |
}else{ |
|
745 |
((MultiPolygon)multiPolygon).addPrimitive((Polygon)polygon); |
|
746 |
} |
|
747 |
} |
|
636 | 748 |
} |
637 | 749 |
|
638 | 750 |
/* (non-Javadoc) |
639 | 751 |
* @see org.gvsig.gpe.GPEContentHandler#addCurveToMultiCurve(java.lang.Object, java.lang.Object) |
640 | 752 |
*/ |
641 | 753 |
public void addCurveToMultiCurve(Object curve, Object multiCurve) { |
642 |
((MultiCurve)multiCurve).addCurve((Curve)curve); |
|
754 |
//((MultiCurve)multiCurve).addCurve((Curve)curve); |
|
755 |
addLineStringToMultiLineString(curve, multiCurve); |
|
643 | 756 |
} |
644 | 757 |
|
645 | 758 |
/* (non-Javadoc) |
... | ... | |
655 | 768 |
for (int i=0; i<n; i++) { |
656 | 769 |
((Curve)curve).addVertex(seg_cur.getVertex(i)); |
657 | 770 |
} |
658 |
|
|
771 |
|
|
659 | 772 |
} else { |
660 | 773 |
LOG.info("Discarded unexpected geometry class: " |
661 | 774 |
+ (segment == null ? "NULL" : segment.getClass().getName())); |
662 | 775 |
} |
663 | 776 |
} |
664 |
|
|
777 |
|
|
665 | 778 |
} |
666 | 779 |
|
667 | 780 |
/* (non-Javadoc) |
... | ... | |
683 | 796 |
*/ |
684 | 797 |
public Object startMultiCurve(String id, String srs, int dimension) { |
685 | 798 |
try { |
686 |
return geomManager.create(TYPES.MULTICURVE, getGeometrySubtype(dimension));
|
|
799 |
return geomManager.create(TYPES.MULTILINE, getGeometrySubtype(dimension));
|
|
687 | 800 |
} catch (CreateGeometryException e) { |
688 | 801 |
getErrorHandler().addError(e); |
689 | 802 |
} |
... | ... | |
691 | 804 |
} |
692 | 805 |
|
693 | 806 |
/* (non-Javadoc) |
807 |
* @see org.gvsig.gpe.GPEContentHandler#startMultiCurve(java.lang.String, java.lang.String) |
|
808 |
*/ |
|
809 |
public Object startMultiCurve(String id, String srs) { |
|
810 |
return startMultiCurve(id,srs,Geometry.SUBTYPES.GEOM2D); |
|
811 |
} |
|
812 |
|
|
813 |
/* (non-Javadoc) |
|
694 | 814 |
* @see org.gvsig.gpe.GPEContentHandler#addGeometryToMultiGeometry(java.lang.Object, java.lang.Object) |
695 | 815 |
*/ |
696 | 816 |
public void addGeometryToMultiGeometry(Object geometry, Object multiGeometry) { |
697 |
((MultiPrimitive)multiGeometry).addPrimitive((Primitive)geometry); |
|
817 |
if (((Geometry)multiGeometry).getGeometryType().isTypeOf(TYPES.MULTILINE) ){ |
|
818 |
((MultiLine)multiGeometry).addPrimitive((Line)geometry); |
|
819 |
} |
|
820 |
if (((Geometry)multiGeometry).getGeometryType().isTypeOf(TYPES.MULTIPOINT) ){ |
|
821 |
((MultiPoint)multiGeometry).addPrimitive((Point)geometry); |
|
822 |
} |
|
823 |
if (((Geometry)multiGeometry).getGeometryType().isTypeOf(TYPES.MULTIPOLYGON) ){ |
|
824 |
((MultiPolygon)multiGeometry).addPrimitive((Polygon)geometry); |
|
825 |
} |
|
698 | 826 |
} |
699 | 827 |
|
700 | 828 |
/* (non-Javadoc) |
701 | 829 |
* @see org.gvsig.gpe.GPEContentHandler#startMultiGeometry(java.lang.String, java.lang.String) |
702 | 830 |
*/ |
703 | 831 |
public Object startMultiGeometry(String id, String srs) { |
704 |
try { |
|
705 |
return geomManager.create(TYPES.AGGREGATE, SUBTYPES.GEOM2D); |
|
706 |
} catch (CreateGeometryException e) { |
|
707 |
getErrorHandler().addError(e); |
|
708 |
} |
|
832 |
// try {
|
|
833 |
// return geomManager.create(TYPES.AGGREGATE, SUBTYPES.GEOM2D);
|
|
834 |
// } catch (CreateGeometryException e) {
|
|
835 |
// getErrorHandler().addError(e);
|
|
836 |
// }
|
|
709 | 837 |
return null; |
710 | 838 |
} |
711 | 839 |
|
... | ... | |
715 | 843 |
public Object createNewOID() { |
716 | 844 |
featureId++; |
717 | 845 |
return String.valueOf(featureId); |
718 |
}
|
|
846 |
} |
|
719 | 847 |
|
720 | 848 |
/** |
721 | 849 |
* @param envelope the envelope to set |
... | ... | |
730 | 858 |
public void setFeatureType(EditableFeatureType featureType) { |
731 | 859 |
this.featureType = featureType; |
732 | 860 |
} |
733 |
|
|
861 |
|
|
734 | 862 |
private int getGeometrySubtype(int dimension) { |
735 | 863 |
switch(dimension) { |
736 | 864 |
case 3: |
737 | 865 |
return Geometry.SUBTYPES.GEOM3D; |
738 | 866 |
default: |
739 | 867 |
case 2: |
740 |
return Geometry.SUBTYPES.GEOM2D;
|
|
868 |
return Geometry.SUBTYPES.GEOM2D; |
|
741 | 869 |
} |
742 | 870 |
} |
743 | 871 |
} |
Also available in: Unified diff