root / org.gvsig.dxf / trunk / org.gvsig.dxf / org.gvsig.dxf.provider / src / main / java / org / gvsig / fmap / dal / store / dxf / DXFStoreProvider.java @ 1272
History | View | Annotate | Download (74.4 KB)
1 |
package org.gvsig.fmap.dal.store.dxf; |
---|---|
2 |
|
3 |
import java.awt.geom.PathIterator; |
4 |
import java.awt.geom.Point2D; |
5 |
import java.io.File; |
6 |
import java.text.MessageFormat; |
7 |
import java.util.ArrayList; |
8 |
import java.util.HashMap; |
9 |
import java.util.Iterator; |
10 |
import java.util.List; |
11 |
import java.util.Map; |
12 |
import java.util.Vector; |
13 |
import org.apache.commons.io.FilenameUtils; |
14 |
import org.apache.commons.lang3.StringUtils; |
15 |
import org.cresques.cts.IProjection; |
16 |
import org.gvsig.dxf.geo.Point3D; |
17 |
import org.gvsig.dxf.io.DxfFile; |
18 |
import org.gvsig.dxf.io.DxfGroup; |
19 |
import org.gvsig.dxf.io.DxfGroupVector; |
20 |
import org.gvsig.dxf.px.IObjList; |
21 |
import org.gvsig.dxf.px.dxf.DxfEntityMaker; |
22 |
import org.gvsig.dxf.px.dxf.DxfFeatureMaker; |
23 |
import org.gvsig.dxf.px.dxf.DxfHeaderManager; |
24 |
import org.gvsig.dxf.px.gml.Feature; |
25 |
import org.gvsig.dxf.px.gml.LineString; |
26 |
import org.gvsig.dxf.px.gml.LineString3D; |
27 |
import org.gvsig.dxf.px.gml.Point; |
28 |
import org.gvsig.dxf.px.gml.Polygon; |
29 |
import org.gvsig.dxf.px.gml.Polygon3D; |
30 |
import org.gvsig.fmap.dal.DALLocator; |
31 |
import org.gvsig.fmap.dal.DataManager; |
32 |
import org.gvsig.fmap.dal.DataServerExplorer; |
33 |
import org.gvsig.fmap.dal.DataStore; |
34 |
import org.gvsig.fmap.dal.DataStoreNotification; |
35 |
import org.gvsig.fmap.dal.DataTypes; |
36 |
import org.gvsig.fmap.dal.FileHelper; |
37 |
import org.gvsig.fmap.dal.exception.DataException; |
38 |
import org.gvsig.fmap.dal.exception.InitializeException; |
39 |
import org.gvsig.fmap.dal.exception.LoadException; |
40 |
import org.gvsig.fmap.dal.exception.OpenException; |
41 |
import org.gvsig.fmap.dal.exception.ReadException; |
42 |
import org.gvsig.fmap.dal.exception.ValidateDataParametersException; |
43 |
import org.gvsig.fmap.dal.exception.WriteException; |
44 |
import org.gvsig.fmap.dal.feature.EditableFeatureAttributeDescriptor; |
45 |
import org.gvsig.fmap.dal.feature.EditableFeatureType; |
46 |
import org.gvsig.fmap.dal.feature.FeatureSet; |
47 |
import org.gvsig.fmap.dal.feature.FeatureType; |
48 |
import org.gvsig.fmap.dal.feature.exception.PerformEditingException; |
49 |
import org.gvsig.fmap.dal.feature.spi.FeatureProvider; |
50 |
import org.gvsig.fmap.dal.feature.spi.FeatureStoreProviderServices; |
51 |
import org.gvsig.fmap.dal.feature.spi.memory.AbstractMemoryStoreProvider; |
52 |
import org.gvsig.fmap.dal.resource.ResourceAction; |
53 |
import org.gvsig.fmap.dal.resource.exception.AccessResourceException; |
54 |
import org.gvsig.fmap.dal.resource.exception.ResourceNotifyCloseException; |
55 |
import org.gvsig.fmap.dal.resource.exception.ResourceNotifyOpenException; |
56 |
import org.gvsig.fmap.dal.resource.file.FileResource; |
57 |
import org.gvsig.fmap.dal.resource.spi.ResourceConsumer; |
58 |
import org.gvsig.fmap.dal.resource.spi.ResourceProvider; |
59 |
import org.gvsig.fmap.dal.serverexplorer.filesystem.FilesystemServerExplorer; |
60 |
import org.gvsig.fmap.dal.serverexplorer.filesystem.FilesystemServerExplorerParameters; |
61 |
import org.gvsig.fmap.dal.spi.DataStoreProviderServices; |
62 |
import org.gvsig.fmap.geom.Geometry; |
63 |
import org.gvsig.fmap.geom.Geometry.SUBTYPES; |
64 |
import org.gvsig.fmap.geom.Geometry.TYPES; |
65 |
import org.gvsig.fmap.geom.GeometryLocator; |
66 |
import org.gvsig.fmap.geom.GeometryManager; |
67 |
import org.gvsig.fmap.geom.aggregate.MultiLine; |
68 |
import org.gvsig.fmap.geom.exception.CreateEnvelopeException; |
69 |
import org.gvsig.fmap.geom.exception.CreateGeometryException; |
70 |
import org.gvsig.fmap.geom.operation.GeometryOperationContext; |
71 |
import org.gvsig.fmap.geom.operation.distance.PointDistance; |
72 |
import org.gvsig.fmap.geom.operation.utils.PointGetAngle; |
73 |
import org.gvsig.fmap.geom.primitive.Arc; |
74 |
import org.gvsig.fmap.geom.primitive.Circle; |
75 |
import org.gvsig.fmap.geom.primitive.Curve; |
76 |
import org.gvsig.fmap.geom.primitive.Ellipse; |
77 |
import org.gvsig.fmap.geom.primitive.Envelope; |
78 |
import org.gvsig.fmap.geom.primitive.Line; |
79 |
import org.gvsig.fmap.geom.primitive.OrientablePrimitive; |
80 |
import org.gvsig.fmap.geom.type.GeometryType; |
81 |
import org.gvsig.fmap.geom.type.GeometryTypeNotSupportedException; |
82 |
import org.gvsig.fmap.geom.type.GeometryTypeNotValidException; |
83 |
import org.gvsig.tools.ToolsLocator; |
84 |
import org.gvsig.tools.dispose.DisposableIterator; |
85 |
import org.gvsig.tools.dynobject.exception.DynFieldNotFoundException; |
86 |
import org.gvsig.tools.dynobject.exception.DynMethodException; |
87 |
import org.gvsig.tools.exception.BaseException; |
88 |
import org.gvsig.tools.exception.NotYetImplemented; |
89 |
import org.gvsig.tools.locator.LocatorException; |
90 |
import org.gvsig.tools.logger.FilteredLogger; |
91 |
import org.gvsig.tools.persistence.PersistentState; |
92 |
import org.gvsig.tools.persistence.exception.PersistenceException; |
93 |
import org.gvsig.tools.task.SimpleTaskStatus; |
94 |
import org.gvsig.tools.task.TaskStatusManager; |
95 |
import org.slf4j.Logger; |
96 |
import org.slf4j.LoggerFactory; |
97 |
|
98 |
/**
|
99 |
* @author gvSIG team
|
100 |
*
|
101 |
*/
|
102 |
public class DXFStoreProvider extends AbstractMemoryStoreProvider implements |
103 |
ResourceConsumer { |
104 |
private static final Logger logger = LoggerFactory.getLogger(DXFStoreProvider.class); |
105 |
|
106 |
public static final String NAME = "DXF"; |
107 |
public static final String DESCRIPTION = "DXF file"; |
108 |
|
109 |
public static final String METADATA_DEFINITION_NAME = NAME; |
110 |
|
111 |
public static final String NAME_FIELD_ID = "ID"; |
112 |
public static final String NAME_FIELD_GEOMETRY = "Geometry"; |
113 |
public static final String NAME_FIELD_ENTITY = "Entity"; |
114 |
public static final String NAME_FIELD_LAYER = "Layer"; |
115 |
public static final String NAME_FIELD_COLOR = "Color"; |
116 |
public static final String NAME_FIELD_ELEVATION = "Elevation"; |
117 |
public static final String NAME_FIELD_THICKNESS = "Thickness"; |
118 |
public static final String NAME_FIELD_TEXT = "Text"; |
119 |
public static final String NAME_FIELD_HEIGHTTEXT = "HeightText"; |
120 |
public static final String NAME_FIELD_ROTATIONTEXT = "Rotation"; |
121 |
|
122 |
private static final int ID_FIELD_ID = 0; |
123 |
private static final int ID_FIELD_GEOMETRY = 1; |
124 |
private static final int ID_FIELD_ENTITY = 2; |
125 |
private static final int ID_FIELD_LAYER = 3; |
126 |
private static final int ID_FIELD_COLOR = 4; |
127 |
private static final int ID_FIELD_ELEVATION = 5; |
128 |
private static final int ID_FIELD_THICKNESS = 6; |
129 |
private static final int ID_FIELD_TEXT = 7; |
130 |
private static final int ID_FIELD_HEIGHTTEXT = 8; |
131 |
private static final int ID_FIELD_ROTATIONTEXT = 9; |
132 |
|
133 |
public static final Integer DEFAULT_VALUE_FIELD_COLOR = 0; |
134 |
public static final Double DEFAULT_VALUE_FIELD_THICKNESS = 0d; |
135 |
public static final String DEFAULT_VALUE_FIELD_LAYER = "default"; |
136 |
|
137 |
private IProjection projection;
|
138 |
private ResourceProvider resource;
|
139 |
private LegendBuilder legendBuilder;
|
140 |
|
141 |
private long counterNewsOIDs = 0; |
142 |
private Envelope envelope;
|
143 |
private Writer writer; |
144 |
protected GeometryManager geomManager = GeometryLocator.getGeometryManager();
|
145 |
|
146 |
private SimpleTaskStatus taskStatus;
|
147 |
|
148 |
|
149 |
/**
|
150 |
* @param parameters
|
151 |
* @param storeServices
|
152 |
* @throws InitializeException
|
153 |
*/
|
154 |
public DXFStoreProvider(DXFOpenStoreParameters parameters,
|
155 |
DataStoreProviderServices storeServices) throws InitializeException {
|
156 |
super(
|
157 |
parameters, |
158 |
storeServices, |
159 |
FileHelper.newMetadataContainer(METADATA_DEFINITION_NAME) |
160 |
); |
161 |
|
162 |
TaskStatusManager manager = ToolsLocator.getTaskStatusManager(); |
163 |
this.taskStatus = manager.createDefaultSimpleTaskStatus("DXF"); |
164 |
|
165 |
counterNewsOIDs = 0;
|
166 |
// projection = CRSFactory.getCRS(getParameters().getSRSID());
|
167 |
|
168 |
File file = getDXFParameters().getFile();
|
169 |
resource = this.createResource(
|
170 |
FileResource.NAME, |
171 |
new Object[] { file.getAbsolutePath() } |
172 |
); |
173 |
|
174 |
resource.addConsumer(this);
|
175 |
|
176 |
this.projection = this.getDXFParameters().getCRS(); |
177 |
|
178 |
|
179 |
try {
|
180 |
legendBuilder = (LegendBuilder) this.invokeDynMethod(
|
181 |
LegendBuilder.DYNMETHOD_BUILDER_NAME, null);
|
182 |
} catch (DynMethodException e) {
|
183 |
legendBuilder = null;
|
184 |
} catch (Exception e) { |
185 |
throw new InitializeException(e); |
186 |
} |
187 |
|
188 |
this.initializeFeatureTypes();
|
189 |
} |
190 |
|
191 |
private DXFOpenStoreParameters getDXFParameters() {
|
192 |
return (DXFOpenStoreParameters) this.getParameters(); |
193 |
} |
194 |
|
195 |
public String getProviderName() { |
196 |
return NAME;
|
197 |
} |
198 |
|
199 |
public boolean allowWrite() { |
200 |
return true; |
201 |
} |
202 |
|
203 |
/**
|
204 |
* @return the legend
|
205 |
* @throws OpenException
|
206 |
*/
|
207 |
public Object getLegend() throws OpenException { |
208 |
this.open();
|
209 |
if (legendBuilder == null) { |
210 |
return null; |
211 |
} |
212 |
return legendBuilder.getLegend();
|
213 |
} |
214 |
|
215 |
/**
|
216 |
* @return the labeling strategy
|
217 |
* @throws OpenException
|
218 |
*/
|
219 |
public Object getLabeling() throws OpenException { |
220 |
this.open();
|
221 |
if (legendBuilder == null) { |
222 |
return null; |
223 |
} |
224 |
return legendBuilder.getLabeling();
|
225 |
} |
226 |
|
227 |
private class DXFData { |
228 |
public List<FeatureProvider> data = null; |
229 |
public FeatureType defaultFType = null; |
230 |
public List<FeatureType> fTypes = null; |
231 |
public Envelope envelope = null; |
232 |
public IProjection projection;
|
233 |
public LegendBuilder legendBuilder;
|
234 |
public Envelope getEnvelopeCopy() throws CreateEnvelopeException { |
235 |
if (envelope == null) { |
236 |
return null; |
237 |
} |
238 |
Envelope newEnvelope; |
239 |
if (envelope.getDimension() == 2) { |
240 |
newEnvelope = geomManager.createEnvelope(SUBTYPES.GEOM2D); |
241 |
} else {
|
242 |
newEnvelope = geomManager.createEnvelope(SUBTYPES.GEOM3D); |
243 |
|
244 |
} |
245 |
newEnvelope.setLowerCorner(envelope.getLowerCorner()); |
246 |
newEnvelope.setUpperCorner(envelope.getUpperCorner()); |
247 |
return newEnvelope;
|
248 |
} |
249 |
} |
250 |
|
251 |
public void open() throws OpenException { |
252 |
if (this.data != null) { |
253 |
return;
|
254 |
} |
255 |
openEver(); |
256 |
} |
257 |
|
258 |
private void openEver() throws OpenException { |
259 |
try {
|
260 |
this.taskStatus.add();
|
261 |
getResource().execute(new ResourceAction() {
|
262 |
public Object run() throws Exception { |
263 |
DXFData dxfData = null;
|
264 |
resource.setData(new HashMap<Object, Object>()); |
265 |
FeatureStoreProviderServices store = getStoreServices(); |
266 |
dxfData = new DXFData();
|
267 |
dxfData.data = new ArrayList<FeatureProvider>(); |
268 |
data = dxfData.data; |
269 |
counterNewsOIDs = 0;
|
270 |
File file = (File) resource.get(); |
271 |
Reader reader = new Reader().initialice( |
272 |
getMemoryProvider(), |
273 |
file, |
274 |
projection, |
275 |
legendBuilder |
276 |
); |
277 |
reader.begin(store); |
278 |
dxfData.defaultFType = reader.getDefaultType() |
279 |
.getNotEditableCopy(); |
280 |
ArrayList<FeatureType> types = new ArrayList<FeatureType>(); |
281 |
Iterator<EditableFeatureType> it = reader.getTypes().iterator();
|
282 |
EditableFeatureType fType; |
283 |
while (it.hasNext()) {
|
284 |
fType = it.next(); |
285 |
if (fType.getId().equals(dxfData.defaultFType.getId())) {
|
286 |
types.add(dxfData.defaultFType); |
287 |
} else {
|
288 |
types.add(fType.getNotEditableCopy()); |
289 |
} |
290 |
} |
291 |
dxfData.fTypes = types; |
292 |
|
293 |
resource.notifyOpen(); |
294 |
store.setFeatureTypes(dxfData.fTypes, dxfData.defaultFType); |
295 |
reader.load(); |
296 |
|
297 |
dxfData.envelope = reader.getEnvelope(); |
298 |
|
299 |
dxfData.legendBuilder = legendBuilder; |
300 |
|
301 |
dxfData.projection = projection; |
302 |
|
303 |
reader.end(); |
304 |
resource.notifyClose(); |
305 |
((Map<String, DXFData>) resource.getData()).put(projection.getAbrev(), |
306 |
dxfData); // OJO la reproyeccion
|
307 |
|
308 |
data = dxfData.data; |
309 |
store.setFeatureTypes(dxfData.fTypes, dxfData.defaultFType); |
310 |
legendBuilder = dxfData.legendBuilder; |
311 |
envelope= dxfData.getEnvelopeCopy(); |
312 |
// setDynValue("CRS", projection.getAbrev());
|
313 |
counterNewsOIDs = data.size(); |
314 |
return null; |
315 |
} |
316 |
}); |
317 |
this.taskStatus.terminate();
|
318 |
} catch (Exception e) { |
319 |
data = null;
|
320 |
this.taskStatus.abort();
|
321 |
try {
|
322 |
throw new OpenException(resource.getName(), e); |
323 |
} catch (AccessResourceException e1) {
|
324 |
throw new OpenException(getProviderName(), e); |
325 |
} |
326 |
} finally {
|
327 |
this.taskStatus.remove();
|
328 |
} |
329 |
} |
330 |
|
331 |
|
332 |
public DataServerExplorer getExplorer() throws ReadException { |
333 |
DataManager manager = DALLocator.getDataManager(); |
334 |
FilesystemServerExplorerParameters params; |
335 |
try {
|
336 |
params = (FilesystemServerExplorerParameters) manager |
337 |
.createServerExplorerParameters(FilesystemServerExplorer.NAME); |
338 |
params.setRoot(this.getDXFParameters().getFile().getParent());
|
339 |
return manager.openServerExplorer(FilesystemServerExplorer.NAME,params);
|
340 |
} catch (DataException e) {
|
341 |
throw new ReadException(this.getProviderName(), e); |
342 |
} catch (ValidateDataParametersException e) {
|
343 |
throw new ReadException(this.getProviderName(), e); |
344 |
} |
345 |
|
346 |
} |
347 |
|
348 |
|
349 |
|
350 |
public void performChanges(Iterator deleteds, Iterator inserteds, Iterator updateds, Iterator originalFeatureTypesUpdated) throws PerformEditingException { |
351 |
|
352 |
try {
|
353 |
this.taskStatus.add();
|
354 |
taskStatus.message("_preparing");
|
355 |
getResource().execute(new ResourceAction() {
|
356 |
public Object run() throws Exception { |
357 |
FeatureSet features = null;
|
358 |
DisposableIterator it = null;
|
359 |
counterNewsOIDs = 0;
|
360 |
try {
|
361 |
File file = (File) resource.get(); |
362 |
writer = new Writer().initialice(file, projection); |
363 |
features = |
364 |
getStoreServices().getFeatureStore() |
365 |
.getFeatureSet(); |
366 |
List<FeatureProvider> newdata = new ArrayList<FeatureProvider>(); |
367 |
writer.begin(); |
368 |
it = features.fastIterator(); |
369 |
taskStatus.setRangeOfValues(0,0); |
370 |
long counter=0; |
371 |
while (it.hasNext()) {
|
372 |
taskStatus.setCurValue(counter++); |
373 |
FeatureProvider featureProvider = getStoreServices().getFeatureProviderFromFeature( |
374 |
(org.gvsig.fmap.dal.feature.Feature) it.next()); |
375 |
writer.add(featureProvider); |
376 |
featureProvider.setOID(createNewOID()); |
377 |
newdata.add(featureProvider); |
378 |
} |
379 |
data = newdata; |
380 |
writer.end(); |
381 |
if (writer.getEnvelope() != null){ |
382 |
envelope = writer.getEnvelope().getGeometry().getEnvelope(); |
383 |
} |
384 |
resource.notifyChanges(); |
385 |
// counterNewsOIDs = 0;
|
386 |
|
387 |
savePrjFile(file, projection); |
388 |
|
389 |
} finally {
|
390 |
if (it != null) { |
391 |
it.dispose(); |
392 |
} |
393 |
if (features != null) { |
394 |
features.dispose(); |
395 |
} |
396 |
} |
397 |
return null; |
398 |
} |
399 |
}); |
400 |
this.taskStatus.terminate();
|
401 |
} catch (Exception e) { |
402 |
this.taskStatus.abort();
|
403 |
throw new PerformEditingException(getResource().toString(), e); |
404 |
} finally {
|
405 |
this.taskStatus.remove();
|
406 |
} |
407 |
} |
408 |
|
409 |
/**
|
410 |
* @param featureType
|
411 |
* @param projection
|
412 |
* @param geometrySubtype
|
413 |
* @throws LocatorException
|
414 |
* @throws GeometryTypeNotValidException
|
415 |
* @throws GeometryTypeNotSupportedException
|
416 |
*/
|
417 |
public static void initializeFeatureType(EditableFeatureType featureType, IProjection projection, int geometrySubtype) { |
418 |
featureType.setHasOID(true);
|
419 |
|
420 |
// ID_FIELD_ID = 0;
|
421 |
featureType.add(NAME_FIELD_ID, DataTypes.INT) |
422 |
.setDefaultValue(Integer.valueOf(0)) |
423 |
.getIndex(); |
424 |
|
425 |
EditableFeatureAttributeDescriptor attr = featureType.add( |
426 |
NAME_FIELD_GEOMETRY, DataTypes.GEOMETRY); |
427 |
attr.setSRS(projection); |
428 |
GeometryManager geometryManager = GeometryLocator.getGeometryManager(); |
429 |
|
430 |
try {
|
431 |
GeometryType geometryType = geometryManager.getGeometryType(Geometry.TYPES.GEOMETRY, geometrySubtype); |
432 |
attr.setGeometryType(geometryType); |
433 |
} catch (GeometryTypeNotSupportedException | GeometryTypeNotValidException e) {
|
434 |
logger.error("Can't create geometry type " + Geometry.TYPES.GEOMETRY + " with subtype " + geometrySubtype, e); |
435 |
attr.setGeometryType(Geometry.TYPES.GEOMETRY); |
436 |
attr.setGeometrySubType(geometrySubtype); |
437 |
} |
438 |
|
439 |
// ID_FIELD_GEOMETRY = 1; //attr.getIndex();
|
440 |
|
441 |
featureType.setDefaultGeometryAttributeName(NAME_FIELD_GEOMETRY); |
442 |
|
443 |
// FIXME: Cual es el size y el valor por defecto para Entity ?
|
444 |
// ID_FIELD_ENTITY = 2;
|
445 |
featureType.add(NAME_FIELD_ENTITY, |
446 |
DataTypes.STRING, 100)
|
447 |
.setDefaultValue("")
|
448 |
.getIndex(); |
449 |
|
450 |
// FIXME: Cual es el size de Layer ?
|
451 |
// ID_FIELD_LAYER = 3;
|
452 |
featureType.add(NAME_FIELD_LAYER, |
453 |
DataTypes.STRING, 100)
|
454 |
.setDefaultValue( |
455 |
DEFAULT_VALUE_FIELD_LAYER).getIndex(); |
456 |
|
457 |
// ID_FIELD_COLOR = 4;
|
458 |
featureType.add(NAME_FIELD_COLOR, |
459 |
DataTypes.INT) |
460 |
.setDefaultValue(DEFAULT_VALUE_FIELD_COLOR) |
461 |
.getIndex(); |
462 |
|
463 |
// ID_FIELD_ELEVATION = 5;
|
464 |
featureType.add(NAME_FIELD_ELEVATION, |
465 |
DataTypes.DOUBLE) |
466 |
.setDefaultValue( |
467 |
Double.valueOf(0)).getIndex(); |
468 |
|
469 |
// ID_FIELD_THICKNESS = 6;
|
470 |
featureType.add(NAME_FIELD_THICKNESS, |
471 |
DataTypes.DOUBLE) |
472 |
.setDefaultValue(DEFAULT_VALUE_FIELD_THICKNESS).getIndex(); |
473 |
|
474 |
// FIXME: Cual es el size de Text ?
|
475 |
// ID_FIELD_TEXT = 7;
|
476 |
featureType.add(NAME_FIELD_TEXT, |
477 |
DataTypes.STRING, 100)
|
478 |
.setDefaultValue("")
|
479 |
.getIndex(); |
480 |
|
481 |
// ID_FIELD_HEIGHTTEXT = 8;
|
482 |
featureType.add(NAME_FIELD_HEIGHTTEXT, |
483 |
DataTypes.DOUBLE).setDefaultValue( |
484 |
Double.valueOf(10)).getIndex(); |
485 |
|
486 |
// ID_FIELD_ROTATIONTEXT = 9;
|
487 |
featureType.add(NAME_FIELD_ROTATIONTEXT, |
488 |
DataTypes.DOUBLE).setDefaultValue( |
489 |
Double.valueOf(0)).getIndex(); |
490 |
|
491 |
// FIXME: Parece que el DXF puede tener mas atributos opcionales.
|
492 |
// Habria que ver de pillarlos ?
|
493 |
|
494 |
} |
495 |
|
496 |
/**
|
497 |
* @author gvSIG team
|
498 |
*
|
499 |
*/
|
500 |
public class Reader { |
501 |
private File file; |
502 |
private String fileName; |
503 |
private IProjection projection;
|
504 |
private List<EditableFeatureType> types; |
505 |
private LegendBuilder leyendBuilder;
|
506 |
private AbstractMemoryStoreProvider store;
|
507 |
private Envelope envelope;
|
508 |
|
509 |
//Next two variables are used to read the DXF file
|
510 |
private DxfFeatureMaker featureMaker;
|
511 |
private DxfHeaderManager headerManager;
|
512 |
|
513 |
/**
|
514 |
* @param store
|
515 |
* @param file
|
516 |
* @param projection
|
517 |
* @param leyendBuilder
|
518 |
* @return the reader
|
519 |
*/
|
520 |
public Reader initialice(AbstractMemoryStoreProvider store, File file, |
521 |
IProjection projection, |
522 |
LegendBuilder leyendBuilder) { |
523 |
this.store = store;
|
524 |
this.file = file;
|
525 |
this.fileName = file.getAbsolutePath();
|
526 |
this.projection = projection;
|
527 |
this.leyendBuilder = leyendBuilder;
|
528 |
if (leyendBuilder != null) { |
529 |
leyendBuilder.initialize(store); |
530 |
} |
531 |
return this; |
532 |
} |
533 |
|
534 |
/**
|
535 |
* @return the envelope
|
536 |
*/
|
537 |
public Envelope getEnvelope() {
|
538 |
return this.envelope; |
539 |
} |
540 |
|
541 |
/**
|
542 |
* @param store
|
543 |
* @throws LoadException
|
544 |
*/
|
545 |
public void begin(FeatureStoreProviderServices store) throws LoadException { |
546 |
taskStatus.message("_preloading_data");
|
547 |
featureMaker = new DxfFeatureMaker(projection);
|
548 |
headerManager = new DxfHeaderManager();
|
549 |
DxfFile dxfFeatureFile = new DxfFile(projection, file
|
550 |
.getAbsolutePath(), featureMaker, headerManager); |
551 |
|
552 |
try {
|
553 |
dxfFeatureFile.load(); |
554 |
} catch (Exception e1) { |
555 |
throw new LoadException(e1, fileName); |
556 |
} |
557 |
|
558 |
taskStatus.message("_preparing_featureType");
|
559 |
int geometrySubtype;
|
560 |
if (featureMaker.isDxf3DFile() && headerManager.isWritedDxf3D()){
|
561 |
geometrySubtype = Geometry.SUBTYPES.GEOM3D; |
562 |
}else{
|
563 |
geometrySubtype = Geometry.SUBTYPES.GEOM2D; |
564 |
} |
565 |
EditableFeatureType featureType = store.createFeatureType(getName()); |
566 |
initializeFeatureType(featureType, this.projection, geometrySubtype);
|
567 |
|
568 |
types = new ArrayList<EditableFeatureType>(); |
569 |
types.add(featureType); |
570 |
|
571 |
if (leyendBuilder != null) { |
572 |
taskStatus.message("_preparing_leyend");
|
573 |
leyendBuilder.begin(); |
574 |
} |
575 |
|
576 |
} |
577 |
|
578 |
/**
|
579 |
*
|
580 |
*/
|
581 |
public void end() { |
582 |
if (leyendBuilder != null) { |
583 |
leyendBuilder.end(); |
584 |
} |
585 |
} |
586 |
|
587 |
/**
|
588 |
* @return the list of feature types
|
589 |
*/
|
590 |
public List<EditableFeatureType> getTypes() { |
591 |
return types;
|
592 |
} |
593 |
|
594 |
/**
|
595 |
* @return the default editable feature type
|
596 |
*/
|
597 |
public EditableFeatureType getDefaultType() {
|
598 |
return types.get(0); |
599 |
} |
600 |
|
601 |
private Double toDouble(String value) { |
602 |
if (value == null) { |
603 |
return Double.valueOf(0); |
604 |
} |
605 |
return Double.valueOf(value); |
606 |
} |
607 |
|
608 |
private FeatureProvider createFeature(Feature fea, FeatureType ft, int id) throws DataException { |
609 |
|
610 |
FeatureProvider feature = store.createFeatureProvider(ft); |
611 |
|
612 |
feature.setOID(new Long(id)); |
613 |
feature.set(ID_FIELD_ID, Integer.valueOf(id));
|
614 |
feature.set(ID_FIELD_ENTITY, fea.getProp("dxfEntity"));
|
615 |
feature.set(ID_FIELD_LAYER, fea.getProp("layer"));
|
616 |
feature.set(ID_FIELD_COLOR, Integer.valueOf(fea.getProp("color"))); |
617 |
feature.set(ID_FIELD_TEXT, fea.getProp("text"));
|
618 |
feature.set(ID_FIELD_HEIGHTTEXT, toDouble(fea.getProp("textHeight")));
|
619 |
feature.set(ID_FIELD_ROTATIONTEXT, toDouble(fea.getProp("textRotation")));
|
620 |
feature.set(ID_FIELD_ELEVATION, toDouble(fea.getProp("elevation")));
|
621 |
feature.set(ID_FIELD_THICKNESS, toDouble(fea.getProp("thickness")));
|
622 |
feature.set(ID_FIELD_GEOMETRY, null);
|
623 |
// FIXME: Habria que pillar el resto de atributos del DXF.
|
624 |
|
625 |
// FIXME: Habia una incongruencia en el codigo ya que al
|
626 |
// campo
|
627 |
// ID_FIELD_GEOMETRY igual le asignaba una geometria que un
|
628 |
// valor de cadena como 'Point3D', 'Polyline2D' o
|
629 |
// 'Polyline3D'
|
630 |
// Faltaria un atributo ID_FIELD_FSHAPE ?
|
631 |
//
|
632 |
return feature;
|
633 |
} |
634 |
|
635 |
private Geometry processPoints(GeometryManager gManager, Feature dxffeature) throws CreateGeometryException { |
636 |
if (dxffeature.getGeometry() instanceof org.gvsig.dxf.px.gml.Point3D) { |
637 |
org.gvsig.dxf.px.gml.Point3D point = (org.gvsig.dxf.px.gml.Point3D) dxffeature.getGeometry(); |
638 |
Point3D pto = point.getPoint3D(0);
|
639 |
org.gvsig.fmap.geom.primitive.Point geom = gManager.createPoint(pto.getX(), pto.getY(), SUBTYPES.GEOM3D); |
640 |
geom.setCoordinateAt(Geometry.DIMENSIONS.Z, pto.getZ()); |
641 |
|
642 |
if (point.isTextPoint()) {
|
643 |
/// TODO labeling
|
644 |
} |
645 |
return geom;
|
646 |
|
647 |
} |
648 |
if (dxffeature.getGeometry() instanceof Point) { |
649 |
Point point = (Point) dxffeature.getGeometry(); |
650 |
Point2D pto = point.get(0); |
651 |
|
652 |
org.gvsig.fmap.geom.primitive.Point geom = gManager.createPoint(pto.getX(), pto.getY(), SUBTYPES.GEOM2D); |
653 |
|
654 |
if (point.isTextPoint()) {
|
655 |
/// TODO labeling
|
656 |
} |
657 |
return geom;
|
658 |
} |
659 |
return null; |
660 |
} |
661 |
|
662 |
private Geometry processLines(GeometryManager gManager, Feature dxffeature) throws CreateGeometryException { |
663 |
if (dxffeature.getGeometry() instanceof LineString3D) { |
664 |
Line line = gManager.createLine(SUBTYPES.GEOM3D);
|
665 |
for (int j = 0; j < dxffeature.getGeometry().pointNr(); j++) { |
666 |
Point3D point = ((LineString3D) dxffeature.getGeometry()).getPoint3D(j); |
667 |
line.addVertex(point.getX(), point.getY(), point.getZ()); |
668 |
} |
669 |
return line;
|
670 |
|
671 |
} |
672 |
if (dxffeature.getGeometry() instanceof LineString) { |
673 |
Line line = gManager.createLine(SUBTYPES.GEOM2D);
|
674 |
for (int j = 0; j < dxffeature.getGeometry().pointNr(); j++) { |
675 |
Point2D point = dxffeature.getGeometry().get(j);
|
676 |
line.addVertex(point.getX(), point.getY()); |
677 |
} |
678 |
return line;
|
679 |
} |
680 |
return null; |
681 |
} |
682 |
|
683 |
private Geometry processPolygons(GeometryManager gManager, Feature dxffeature) throws CreateGeometryException { |
684 |
org.gvsig.dxf.px.gml.Geometry geom = dxffeature.getGeometry(); |
685 |
if( geom instanceof Polygon ) { |
686 |
if ( ((Polygon) geom).is3D() ) { |
687 |
org.gvsig.fmap.geom.primitive.Polygon polygon = gManager.createPolygon(SUBTYPES.GEOM3D); |
688 |
for (int j = 0; j < dxffeature.getGeometry().pointNr(); j++) { |
689 |
Point3D point = (Point3D) dxffeature.getGeometry().get(j); |
690 |
polygon.addVertex(point.getX(), point.getY(), point.getZ()); |
691 |
} |
692 |
Point3D point = (Point3D) dxffeature.getGeometry().get(0);
|
693 |
polygon.addVertex(point.getX(), point.getY(), point.getZ()); |
694 |
return polygon;
|
695 |
|
696 |
} else {
|
697 |
org.gvsig.fmap.geom.primitive.Polygon polygon = gManager.createPolygon(SUBTYPES.GEOM2D); |
698 |
for (int j = 0; j < dxffeature.getGeometry().pointNr(); j++) { |
699 |
Point2D point = dxffeature.getGeometry().get(j);
|
700 |
polygon.addVertex(point.getX(), point.getY()); |
701 |
} |
702 |
Point2D point = dxffeature.getGeometry().get(0); |
703 |
polygon.addVertex(point.getX(), point.getY()); |
704 |
return polygon;
|
705 |
} |
706 |
} |
707 |
return null; |
708 |
} |
709 |
|
710 |
private void addGeometryToFeature(Geometry geometry, FeatureProvider feature) { |
711 |
if( geometry != null ) { |
712 |
feature.set(ID_FIELD_GEOMETRY, geometry); |
713 |
feature.setDefaultGeometry(geometry); |
714 |
if (this.envelope == null) { |
715 |
this.envelope = geometry.getEnvelope();
|
716 |
} else {
|
717 |
this.envelope.add(geometry.getEnvelope());
|
718 |
} |
719 |
} |
720 |
} |
721 |
|
722 |
private void addfeatureToLegend(FeatureProvider feature) { |
723 |
if (leyendBuilder != null) { |
724 |
try {
|
725 |
leyendBuilder.process(feature); |
726 |
} catch (Exception e) { |
727 |
logger.warn( |
728 |
MessageFormat.format(
|
729 |
"load: legendBuilder process fails in the feature {1}",
|
730 |
feature |
731 |
) |
732 |
); |
733 |
} |
734 |
} |
735 |
} |
736 |
|
737 |
/**
|
738 |
* @throws DataException
|
739 |
*/
|
740 |
public void load() throws DataException { |
741 |
|
742 |
this.envelope = null; |
743 |
|
744 |
IObjList.vector features = (IObjList.vector)featureMaker.getObjects(); |
745 |
String acadVersion = headerManager.getAcadVersion();
|
746 |
|
747 |
logger.info("load: acadVersion = '" + acadVersion + "'"); |
748 |
|
749 |
GeometryManager gManager = GeometryLocator.getGeometryManager(); |
750 |
|
751 |
if (!featureMaker.isDxf3DFile() && !headerManager.isWritedDxf3D()) {
|
752 |
taskStatus.message("_fixing_3dgeometries");
|
753 |
Feature[] features2D = new Feature[features.size()]; |
754 |
taskStatus.setRangeOfValues(0,features.size());
|
755 |
for (int i = 0; i < features.size(); i++) { |
756 |
taskStatus.setCurValue(i); |
757 |
Feature fea = (Feature) features.get(i); |
758 |
if (fea.getGeometry() instanceof org.gvsig.dxf.px.gml.Point3D) { |
759 |
Point point = (Point) fea.getGeometry(); |
760 |
Point point2 = new Point(); |
761 |
for (int j = 0; j < point.pointNr(); j++) { |
762 |
point2.add(point.get(j)); |
763 |
} |
764 |
point2.setTextPoint(point.isTextPoint()); |
765 |
fea.setGeometry(point2); |
766 |
features2D[i] = fea; |
767 |
|
768 |
} else if (fea.getGeometry() instanceof LineString3D) { |
769 |
LineString lineString = (LineString) fea.getGeometry(); |
770 |
LineString lineString2 = new LineString();
|
771 |
for (int j = 0; j < lineString.pointNr(); j++) { |
772 |
lineString2.add(lineString.get(j)); |
773 |
} |
774 |
fea.setGeometry(lineString2); |
775 |
features2D[i] = fea; |
776 |
} else if (fea.getGeometry() instanceof Polygon3D) { |
777 |
Polygon polygon = (Polygon) fea.getGeometry(); |
778 |
Polygon polygon2 = new Polygon(); |
779 |
for (int j = 0; j < polygon.pointNr(); j++) { |
780 |
polygon2.add(polygon.get(j)); |
781 |
} |
782 |
fea.setGeometry(polygon2); |
783 |
features2D[i] = fea; |
784 |
} |
785 |
} |
786 |
features.clear(); |
787 |
for (int i = 0; i < features2D.length; i++) { |
788 |
features.add(features2D[i]); |
789 |
} |
790 |
} |
791 |
|
792 |
FilteredLogger logger = new FilteredLogger(DXFStoreProvider.logger,"DXFLoafing",20); |
793 |
|
794 |
FeatureType ft = store.getStoreServices().getDefaultFeatureType(); |
795 |
taskStatus.message("_loading");
|
796 |
// Nos recorremos las geometrias tres veces para cargarlas en orden:
|
797 |
// - poligonos
|
798 |
// - lineas
|
799 |
// - puntos
|
800 |
// Y garantizar que siempre se pinten los puntos sobre lineas y
|
801 |
// poligonos y las lineas sobre los polignos.
|
802 |
int n = 0; |
803 |
taskStatus.setRangeOfValues(0,features.size()*3); |
804 |
for (int i = 0; i < features.size(); i++) { |
805 |
taskStatus.setCurValue(n++); |
806 |
try {
|
807 |
Feature dxffeature = (Feature) features.get(i); |
808 |
FeatureProvider feature = createFeature(dxffeature, ft, i); |
809 |
Geometry geometry = processPolygons(gManager, dxffeature); |
810 |
if( geometry != null ) { |
811 |
addGeometryToFeature(geometry, feature); |
812 |
store.addFeatureProvider(feature); |
813 |
addfeatureToLegend(feature); |
814 |
} |
815 |
} catch (Exception e) { |
816 |
logger.warn("Can't proccess feature '"+i+", of file '"+fileName+"'.", e); |
817 |
} |
818 |
} |
819 |
for (int i = 0; i < features.size(); i++) { |
820 |
taskStatus.setCurValue(n++); |
821 |
try {
|
822 |
Feature dxffeature = (Feature) features.get(i); |
823 |
FeatureProvider feature = createFeature(dxffeature, ft, i); |
824 |
Geometry geometry = processLines(gManager, dxffeature); |
825 |
if( geometry != null ) { |
826 |
addGeometryToFeature(geometry, feature); |
827 |
store.addFeatureProvider(feature); |
828 |
addfeatureToLegend(feature); |
829 |
} |
830 |
} catch (Exception e) { |
831 |
logger.warn("Can't proccess feature '"+i+", of file '"+fileName+"'.", e); |
832 |
} |
833 |
} |
834 |
for (int i = 0; i < features.size(); i++) { |
835 |
taskStatus.setCurValue(n++); |
836 |
try {
|
837 |
Feature dxffeature = (Feature) features.get(i); |
838 |
FeatureProvider feature = createFeature(dxffeature, ft, i); |
839 |
Geometry geometry = processPoints(gManager, dxffeature); |
840 |
if( geometry != null ) { |
841 |
addGeometryToFeature(geometry, feature); |
842 |
store.addFeatureProvider(feature); |
843 |
addfeatureToLegend(feature); |
844 |
} |
845 |
} catch (Exception e) { |
846 |
logger.warn("Can't proccess feature '"+i+", of file '"+fileName+"'.", e); |
847 |
} |
848 |
} |
849 |
} |
850 |
|
851 |
} |
852 |
|
853 |
/**
|
854 |
* @author gvSIG team
|
855 |
*
|
856 |
*/
|
857 |
public class Writer { |
858 |
private Double DEFAULT_ELEVATION = new Double(0); |
859 |
|
860 |
private DxfFile.EntityFactory entityMaker;
|
861 |
|
862 |
private IProjection proj = null; |
863 |
|
864 |
private int handle = 40; // Revisar porqu� es 40. |
865 |
|
866 |
private int k = 0; |
867 |
|
868 |
private boolean dxf3DFile = false; |
869 |
private String fileName; |
870 |
private Envelope envelope;
|
871 |
|
872 |
/**
|
873 |
* @param file
|
874 |
* @param projection
|
875 |
* @return the writer
|
876 |
*/
|
877 |
public Writer initialice(File file, IProjection projection) { |
878 |
this.proj = projection;
|
879 |
this.fileName = file.getAbsolutePath();
|
880 |
entityMaker = new DxfEntityMaker(proj);
|
881 |
return this; |
882 |
} |
883 |
|
884 |
/**
|
885 |
*
|
886 |
*/
|
887 |
public void begin() { |
888 |
envelope = null;
|
889 |
entityMaker = new DxfEntityMaker(proj);
|
890 |
} |
891 |
|
892 |
/**
|
893 |
* @throws WriteException
|
894 |
*/
|
895 |
public void end() throws WriteException { |
896 |
try {
|
897 |
DxfFile dxfFile = new DxfFile(null, fileName, entityMaker); |
898 |
dxfFile.setCadFlag(true);
|
899 |
if (dxf3DFile) {
|
900 |
dxfFile.setDxf3DFlag(true);
|
901 |
} |
902 |
dxfFile.save(fileName); |
903 |
dxfFile.close(); |
904 |
} catch (Exception e) { |
905 |
throw new WriteException(fileName, e); |
906 |
} |
907 |
} |
908 |
|
909 |
/**
|
910 |
* @param feature
|
911 |
* @throws WriteException
|
912 |
*/
|
913 |
public void add(FeatureProvider feature) throws WriteException { |
914 |
try {
|
915 |
Geometry geom = feature.getDefaultGeometry(); |
916 |
if(geom == null){ |
917 |
//FIXME: tirar al log y avisar al usuario
|
918 |
return;
|
919 |
} |
920 |
GeometryType type = geom.getGeometryType(); |
921 |
boolean geometrySupported = true; |
922 |
|
923 |
if ((type.isTypeOf(TYPES.POINT)) && (type.isSubTypeOf(SUBTYPES.GEOM3D) || type.isSubTypeOf(SUBTYPES.GEOM3DM))) {
|
924 |
dxf3DFile = true;
|
925 |
k = createPoint3D(handle, k, feature); |
926 |
|
927 |
} else if ((type.isTypeOf(TYPES.POINT)) && (SUBTYPES.GEOM2D == type.getSubType())) { |
928 |
k = createPoint2D(handle, k, feature); |
929 |
|
930 |
} else if ((type.isTypeOf(TYPES.ARC)) && (SUBTYPES.GEOM2D == type.getSubType())) { |
931 |
k = createArc2D(handle, k, feature); |
932 |
|
933 |
} else if ((type.isTypeOf(TYPES.CURVE) || type.isTypeOf(TYPES.MULTICURVE)) && (type.isSubTypeOf(SUBTYPES.GEOM3D) || type.isSubTypeOf(SUBTYPES.GEOM3DM))) { |
934 |
dxf3DFile = true;
|
935 |
k = createPolyline3D(handle, k, feature, false);
|
936 |
|
937 |
} else if ((type.isTypeOf(TYPES.CURVE) || type.isTypeOf(TYPES.MULTICURVE)) && (SUBTYPES.GEOM2D == type.getSubType())) { |
938 |
k = createLwPolyline2D(handle, k, feature, false);
|
939 |
|
940 |
} else if ((type.isTypeOf(TYPES.CIRCLE)) && (SUBTYPES.GEOM2D == type.getSubType())) { |
941 |
k = createCircle2D(handle, k, feature); |
942 |
|
943 |
} else if ((type.isTypeOf(TYPES.ELLIPSE)) && (SUBTYPES.GEOM2D == type.getSubType())) { |
944 |
k = createEllipse2D(handle, k, feature); |
945 |
|
946 |
} else if ((type.isTypeOf(TYPES.SURFACE) || (type.isTypeOf(TYPES.MULTISURFACE))) && (type.isSubTypeOf(SUBTYPES.GEOM3D) || type.isSubTypeOf(SUBTYPES.GEOM3DM))) { |
947 |
|
948 |
dxf3DFile = true;
|
949 |
k = createPolyline3D(handle, k, feature, true);
|
950 |
|
951 |
} else if ((type.isTypeOf(TYPES.SURFACE) || (type.isTypeOf(TYPES.MULTISURFACE))) && (SUBTYPES.GEOM2D == type.getSubType())) { |
952 |
k = createLwPolyline2D(handle, k, feature, true);
|
953 |
|
954 |
} else {
|
955 |
geometrySupported = false;
|
956 |
logger.warn( |
957 |
MessageFormat.format(
|
958 |
"Geometry '{1}' not yet supported",
|
959 |
new Object[] {geom.getClass().getName()} |
960 |
) |
961 |
); |
962 |
k++; |
963 |
} |
964 |
if (geometrySupported){
|
965 |
if (this.envelope != null){ |
966 |
this.envelope.add(feature.getDefaultEnvelope());
|
967 |
} else {
|
968 |
this.envelope = feature.getDefaultEnvelope().getGeometry().getEnvelope();
|
969 |
} |
970 |
} |
971 |
} catch (Exception e) { |
972 |
throw new WriteException(fileName, e); |
973 |
} |
974 |
|
975 |
} |
976 |
|
977 |
private boolean hasText(FeatureProvider feature) { |
978 |
if (feature.isNull(ID_FIELD_TEXT)) {
|
979 |
return false; |
980 |
} |
981 |
if (feature.get(ID_FIELD_TEXT).equals("")) { |
982 |
return false; |
983 |
} |
984 |
return true; |
985 |
} |
986 |
|
987 |
private DxfGroupVector updateProperties(FeatureProvider feature, int k) { |
988 |
DxfGroupVector polv = new DxfGroupVector();
|
989 |
|
990 |
String layer = (String) feature.get(ID_FIELD_LAYER); |
991 |
if(StringUtils.isBlank(layer)){
|
992 |
layer = DEFAULT_VALUE_FIELD_LAYER; |
993 |
} |
994 |
Integer color = (Integer) feature.get(ID_FIELD_COLOR); |
995 |
if(color == null) { |
996 |
color = DEFAULT_VALUE_FIELD_COLOR; |
997 |
} |
998 |
Double thickness = (Double) feature.get(ID_FIELD_THICKNESS); |
999 |
if(thickness == null) { |
1000 |
thickness = DEFAULT_VALUE_FIELD_THICKNESS; |
1001 |
} |
1002 |
|
1003 |
DxfGroup geometryLayer = new DxfGroup(8, layer); |
1004 |
|
1005 |
DxfGroup handleGroup = new DxfGroup();
|
1006 |
handleGroup.setCode(5);
|
1007 |
handleGroup.setData(new Integer(handle + k).toString()); |
1008 |
|
1009 |
DxfGroup handleColor = new DxfGroup();
|
1010 |
handleColor.setCode(62);
|
1011 |
handleColor.setData(color); |
1012 |
|
1013 |
DxfGroup handleThickness = new DxfGroup();
|
1014 |
handleThickness.setCode(39);
|
1015 |
handleThickness.setData(thickness); |
1016 |
|
1017 |
polv.add(geometryLayer); |
1018 |
polv.add(handleGroup); |
1019 |
polv.add(handleColor); |
1020 |
|
1021 |
// DxfGroup prueba = new DxfGroup();
|
1022 |
// prueba.setCode(1000);
|
1023 |
// prueba.setData("prueba");
|
1024 |
// polv.add(prueba);
|
1025 |
return polv;
|
1026 |
} |
1027 |
|
1028 |
private int createPoint2D(int handle, int k, FeatureProvider feature) |
1029 |
throws Exception { |
1030 |
|
1031 |
if (hasText(feature)) {
|
1032 |
return createText2D(handle, k, feature);
|
1033 |
} |
1034 |
org.gvsig.fmap.geom.primitive.Point point = geomManager.createPoint(0, 0, SUBTYPES.GEOM2D); |
1035 |
double[] pointCoords = new double[6]; |
1036 |
PathIterator pointIt = (feature.getDefaultGeometry())
|
1037 |
.getPathIterator(null);
|
1038 |
while (!pointIt.isDone()) {
|
1039 |
pointIt.currentSegment(pointCoords); |
1040 |
point = geomManager.createPoint(pointCoords[0], pointCoords[1], SUBTYPES.GEOM2D); |
1041 |
pointIt.next(); |
1042 |
} |
1043 |
Point2D pto = new Point2D.Double(point.getX(), point.getY()); |
1044 |
|
1045 |
DxfGroup px = new DxfGroup();
|
1046 |
DxfGroup py = new DxfGroup();
|
1047 |
DxfGroup pz = new DxfGroup();
|
1048 |
px.setCode(10);
|
1049 |
px.setData(new Double(pto.getX())); |
1050 |
py.setCode(20);
|
1051 |
py.setData(new Double(pto.getY())); |
1052 |
pz.setCode(30);
|
1053 |
// FIXME: POINT del DXF tiene cota. Le asigno cero arbitrariamente.
|
1054 |
pz.setData(new Double(0.0)); |
1055 |
DxfGroupVector pv = updateProperties(feature, k); |
1056 |
pv.add(px); |
1057 |
pv.add(py); |
1058 |
pv.add(pz); |
1059 |
entityMaker.createPoint(pv); |
1060 |
k++; |
1061 |
return k;
|
1062 |
} |
1063 |
|
1064 |
private int createText2D(int handle, int k, FeatureProvider feature) |
1065 |
throws Exception { |
1066 |
|
1067 |
String text = feature.get(ID_FIELD_TEXT).toString();
|
1068 |
Double heightText = (Double) feature.get(ID_FIELD_HEIGHTTEXT); |
1069 |
Double rotationText = (Double) feature.get(ID_FIELD_ROTATIONTEXT); |
1070 |
|
1071 |
DxfGroup handleText = new DxfGroup();
|
1072 |
handleText.setCode(1);
|
1073 |
handleText.setData(text); |
1074 |
|
1075 |
DxfGroup handleHeightText = new DxfGroup();
|
1076 |
handleHeightText.setCode(40);
|
1077 |
handleHeightText.setData(heightText); |
1078 |
|
1079 |
DxfGroup handleRotationText = new DxfGroup();
|
1080 |
handleRotationText.setCode(50);
|
1081 |
handleRotationText.setData(rotationText); |
1082 |
|
1083 |
org.gvsig.fmap.geom.primitive.Point point = geomManager.createPoint(0, 0, SUBTYPES.GEOM2D); |
1084 |
double[] pointCoords = new double[6]; |
1085 |
PathIterator pointIt = (feature.getDefaultGeometry())
|
1086 |
.getPathIterator(null);
|
1087 |
while (!pointIt.isDone()) {
|
1088 |
pointIt.currentSegment(pointCoords); |
1089 |
point = geomManager.createPoint(pointCoords[0], pointCoords[1], SUBTYPES.GEOM2D); |
1090 |
pointIt.next(); |
1091 |
} |
1092 |
Point2D pto = new Point2D.Double(point.getX(), point.getY()); |
1093 |
DxfGroup handleGroup = new DxfGroup();
|
1094 |
handleGroup.setCode(5);
|
1095 |
handleGroup.setData(new Integer(handle + k).toString()); |
1096 |
DxfGroup px = new DxfGroup();
|
1097 |
DxfGroup py = new DxfGroup();
|
1098 |
DxfGroup pz = new DxfGroup();
|
1099 |
px.setCode(10);
|
1100 |
px.setData(new Double(pto.getX())); |
1101 |
py.setCode(20);
|
1102 |
py.setData(new Double(pto.getY())); |
1103 |
pz.setCode(30);
|
1104 |
// FIXME: POINT del DXF tiene cota. Le asigno cero arbitrariamente.
|
1105 |
pz.setData(new Double(0.0)); |
1106 |
DxfGroupVector pv = updateProperties(feature, k); |
1107 |
pv.add(handleText); |
1108 |
pv.add(handleHeightText); |
1109 |
pv.add(handleRotationText); |
1110 |
pv.add(handleGroup); |
1111 |
pv.add(px); |
1112 |
pv.add(py); |
1113 |
pv.add(pz); |
1114 |
entityMaker.createText(pv); |
1115 |
k++; |
1116 |
return k;
|
1117 |
} |
1118 |
|
1119 |
private int createPoint3D(int handle, int k, FeatureProvider feature) |
1120 |
throws Exception { |
1121 |
if (hasText(feature)) {
|
1122 |
return createText3D(handle, k, feature);
|
1123 |
} |
1124 |
org.gvsig.fmap.geom.primitive.Point point = (org.gvsig.fmap.geom.primitive.Point)geomManager.create(TYPES.POINT, SUBTYPES.GEOM3D); |
1125 |
double[] pointCoords = new double[6]; |
1126 |
PathIterator pointIt = (feature.getDefaultGeometry())
|
1127 |
.getPathIterator(null);
|
1128 |
while (!pointIt.isDone()) {
|
1129 |
pointIt.currentSegment(pointCoords); |
1130 |
point = (org.gvsig.fmap.geom.primitive.Point)geomManager.create(TYPES.POINT, SUBTYPES.GEOM3D); |
1131 |
point.setCoordinateAt(0, pointCoords[0]); |
1132 |
point.setCoordinateAt(1, pointCoords[1]); |
1133 |
point.setCoordinateAt(2, pointCoords[2]); |
1134 |
pointIt.next(); |
1135 |
} |
1136 |
org.gvsig.fmap.geom.primitive.Point pto = (org.gvsig.fmap.geom.primitive.Point)geomManager.create(TYPES.POINT, SUBTYPES.GEOM3D); |
1137 |
pto.setCoordinateAt(0, point.getCoordinateAt(0)); |
1138 |
pto.setCoordinateAt(1, point.getCoordinateAt(1)); |
1139 |
pto.setCoordinateAt(2, point.getCoordinateAt(2)); |
1140 |
DxfGroup px = new DxfGroup();
|
1141 |
DxfGroup py = new DxfGroup();
|
1142 |
DxfGroup pz = new DxfGroup();
|
1143 |
px.setCode(10);
|
1144 |
px.setData(new Double(pto.getX())); |
1145 |
py.setCode(20);
|
1146 |
py.setData(new Double(pto.getY())); |
1147 |
pz.setCode(30);
|
1148 |
pz.setData(new Double(pto.getCoordinateAt(2))); |
1149 |
double velev = ((org.gvsig.fmap.geom.primitive.Point) feature.getDefaultGeometry())
|
1150 |
.getCoordinateAt(2);
|
1151 |
Double elevation = DEFAULT_ELEVATION;
|
1152 |
elevation = new Double(velev); |
1153 |
DxfGroup handleElevation = new DxfGroup();
|
1154 |
handleElevation.setCode(38);
|
1155 |
handleElevation.setData(elevation); |
1156 |
|
1157 |
DxfGroupVector pv = updateProperties(feature, k); |
1158 |
pv.add(handleElevation); |
1159 |
pv.add(px); |
1160 |
pv.add(py); |
1161 |
pv.add(pz); |
1162 |
entityMaker.createPoint(pv); |
1163 |
k++; |
1164 |
return k;
|
1165 |
} |
1166 |
|
1167 |
private int createText3D(int handle, int k, FeatureProvider feature) |
1168 |
throws Exception { |
1169 |
|
1170 |
double velev = ((org.gvsig.fmap.geom.primitive.Point) feature.getDefaultGeometry())
|
1171 |
.getCoordinateAt(0);
|
1172 |
|
1173 |
Double elevation = new Double(velev); |
1174 |
String text = feature.get(ID_FIELD_TEXT).toString();
|
1175 |
Double heightText = (Double) feature.get(ID_FIELD_HEIGHTTEXT); |
1176 |
Double rotationText = (Double) feature.get(ID_FIELD_ROTATIONTEXT); |
1177 |
|
1178 |
DxfGroup handleText = new DxfGroup();
|
1179 |
handleText.setCode(1);
|
1180 |
handleText.setData(text); |
1181 |
|
1182 |
DxfGroup handleHeightText = new DxfGroup();
|
1183 |
handleHeightText.setCode(40);
|
1184 |
handleHeightText.setData(heightText); |
1185 |
|
1186 |
DxfGroup handleRotationText = new DxfGroup();
|
1187 |
handleRotationText.setCode(50);
|
1188 |
handleRotationText.setData(rotationText); |
1189 |
|
1190 |
DxfGroup handleElevation = new DxfGroup();
|
1191 |
handleElevation.setCode(38);
|
1192 |
handleElevation.setData(elevation); |
1193 |
|
1194 |
org.gvsig.fmap.geom.primitive.Point point = |
1195 |
(org.gvsig.fmap.geom.primitive.Point) (feature |
1196 |
.getDefaultGeometry()); |
1197 |
|
1198 |
DxfGroup handleGroup = new DxfGroup();
|
1199 |
handleGroup.setCode(5);
|
1200 |
handleGroup.setData(new Integer(handle + k).toString()); |
1201 |
DxfGroup px = new DxfGroup();
|
1202 |
DxfGroup py = new DxfGroup();
|
1203 |
DxfGroup pz = new DxfGroup();
|
1204 |
px.setCode(10);
|
1205 |
px.setData(new Double(point.getX())); |
1206 |
py.setCode(20);
|
1207 |
py.setData(new Double(point.getY())); |
1208 |
pz.setCode(30);
|
1209 |
pz.setData(new Double(point.getCoordinateAt(2))); |
1210 |
DxfGroupVector pv = updateProperties(feature, k); |
1211 |
pv.add(handleElevation); |
1212 |
pv.add(handleText); |
1213 |
pv.add(handleHeightText); |
1214 |
pv.add(handleRotationText); |
1215 |
pv.add(handleGroup); |
1216 |
pv.add(px); |
1217 |
pv.add(py); |
1218 |
pv.add(pz); |
1219 |
entityMaker.createText(pv); |
1220 |
k++; |
1221 |
return k;
|
1222 |
} |
1223 |
|
1224 |
|
1225 |
private int createLwPolyline2D(int handle, int k, FeatureProvider feature, |
1226 |
boolean isPolygon) throws Exception { |
1227 |
|
1228 |
Geometry geom = feature.getDefaultGeometry(); |
1229 |
MultiLine lines = geom.toLines(); |
1230 |
for (Geometry line : lines) {
|
1231 |
|
1232 |
DxfGroup polylineFlag = new DxfGroup();
|
1233 |
polylineFlag.setCode(70);
|
1234 |
if (isPolygon) {
|
1235 |
polylineFlag.setData(1); // cerrada |
1236 |
} else {
|
1237 |
polylineFlag.setData(0); // abierta |
1238 |
} |
1239 |
|
1240 |
DxfGroupVector polv = updateProperties(feature, k); |
1241 |
polv.add(polylineFlag); |
1242 |
k++; |
1243 |
|
1244 |
Line curve = (Line)line; |
1245 |
for (int i = 0; i < curve.getNumVertices(); i++) { |
1246 |
org.gvsig.fmap.geom.primitive.Point point = curve.get(i); |
1247 |
DxfGroup xvertex = new DxfGroup();
|
1248 |
xvertex.setCode(10);
|
1249 |
xvertex.setData(point.getX()); |
1250 |
DxfGroup yvertex = new DxfGroup();
|
1251 |
yvertex.setCode(20);
|
1252 |
yvertex.setData(point.getY()); |
1253 |
polv.add(xvertex); |
1254 |
polv.add(yvertex); |
1255 |
} |
1256 |
entityMaker.createLwPolyline(polv); |
1257 |
} |
1258 |
return k;
|
1259 |
} |
1260 |
|
1261 |
|
1262 |
private int createLwPolyline2D_OLD(int handle, int k, FeatureProvider feature, |
1263 |
boolean isPolygon) throws Exception { |
1264 |
boolean first = true; |
1265 |
DxfGroupVector polv = updateProperties(feature, k); |
1266 |
Vector<org.gvsig.fmap.geom.primitive.Point> vpoints = new Vector<org.gvsig.fmap.geom.primitive.Point>(); |
1267 |
|
1268 |
DxfGroup polylineFlag = new DxfGroup();
|
1269 |
polylineFlag.setCode(70);
|
1270 |
if (isPolygon) {
|
1271 |
polylineFlag.setData(new Integer(1)); // cerrada |
1272 |
} else {
|
1273 |
polylineFlag.setData(new Integer(0)); // abierta |
1274 |
} |
1275 |
|
1276 |
PathIterator theIterator = (feature.getDefaultGeometry())
|
1277 |
.getPathIterator(null, geomManager.getFlatness()); // polyLine. |
1278 |
// getPathIterator
|
1279 |
// (null,
|
1280 |
// flatness);
|
1281 |
|
1282 |
double[] theData = new double[6]; |
1283 |
while (!theIterator.isDone()) {
|
1284 |
int theType = theIterator.currentSegment(theData);
|
1285 |
switch (theType) {
|
1286 |
case PathIterator.SEG_MOVETO: |
1287 |
if (!first) {
|
1288 |
for (int j = 0; j < vpoints.size(); j++) { |
1289 |
DxfGroup xvertex = new DxfGroup();
|
1290 |
xvertex.setCode(10);
|
1291 |
xvertex |
1292 |
.setData(new Double( |
1293 |
vpoints |
1294 |
.get(j).getX())); |
1295 |
DxfGroup yvertex = new DxfGroup();
|
1296 |
yvertex.setCode(20);
|
1297 |
yvertex |
1298 |
.setData(new Double( |
1299 |
vpoints |
1300 |
.get(j).getY())); |
1301 |
polv.add(xvertex); |
1302 |
polv.add(yvertex); |
1303 |
} |
1304 |
|
1305 |
entityMaker.createLwPolyline(polv); |
1306 |
k++; |
1307 |
polv = updateProperties(feature, k); |
1308 |
|
1309 |
} |
1310 |
first = false;
|
1311 |
polv.add(polylineFlag); |
1312 |
vpoints.clear(); |
1313 |
vpoints.add(geomManager.createPoint(theData[0], theData[1], SUBTYPES.GEOM2D)); |
1314 |
break;
|
1315 |
case PathIterator.SEG_LINETO: |
1316 |
vpoints.add(geomManager.createPoint(theData[0], theData[1], SUBTYPES.GEOM2D)); |
1317 |
break;
|
1318 |
case PathIterator.SEG_QUADTO: |
1319 |
break;
|
1320 |
case PathIterator.SEG_CUBICTO: |
1321 |
break;
|
1322 |
case PathIterator.SEG_CLOSE: |
1323 |
polylineFlag.setData(new Integer(1)); // cerrada |
1324 |
break;
|
1325 |
|
1326 |
} |
1327 |
theIterator.next(); |
1328 |
} |
1329 |
|
1330 |
for (int j = 0; j < vpoints.size(); j++) { |
1331 |
DxfGroup xvertex = new DxfGroup();
|
1332 |
xvertex.setCode(10);
|
1333 |
xvertex.setData(new Double(vpoints.get(j).getX())); |
1334 |
DxfGroup yvertex = new DxfGroup();
|
1335 |
yvertex.setCode(20);
|
1336 |
yvertex.setData(new Double(vpoints.get(j).getY())); |
1337 |
polv.add(xvertex); |
1338 |
polv.add(yvertex); |
1339 |
} |
1340 |
|
1341 |
entityMaker.createLwPolyline(polv); |
1342 |
k++; |
1343 |
return k;
|
1344 |
} |
1345 |
|
1346 |
|
1347 |
private int createPolyline3D(int handle, int k, FeatureProvider feature, |
1348 |
boolean isPolygon) throws Exception { |
1349 |
|
1350 |
Geometry geom = feature.getDefaultGeometry(); |
1351 |
MultiLine lines = geom.toLines(); |
1352 |
for (Geometry g : lines) {
|
1353 |
|
1354 |
DxfGroup polylineFlag = new DxfGroup();
|
1355 |
polylineFlag.setCode(70);
|
1356 |
int flag = 0; |
1357 |
if (isPolygon) {
|
1358 |
flag = 1; // cerrada |
1359 |
} |
1360 |
polylineFlag.setData(flag); |
1361 |
|
1362 |
DxfGroupVector polv = updateProperties(feature, k); |
1363 |
polv.add(polylineFlag); |
1364 |
k++; |
1365 |
Line line = (Line)g; |
1366 |
|
1367 |
if (constantElevation(line)) {
|
1368 |
DxfGroup elevation = new DxfGroup();
|
1369 |
elevation.setCode(38);
|
1370 |
elevation.setData(line.getVertex(0).getCoordinateAt(Geometry.DIMENSIONS.Z));
|
1371 |
polv.add(elevation); |
1372 |
|
1373 |
for (int i = 0; i < line.getNumVertices(); i++) { |
1374 |
org.gvsig.fmap.geom.primitive.Point point = line.get(i); |
1375 |
DxfGroup xvertex = new DxfGroup();
|
1376 |
xvertex.setCode(10);
|
1377 |
xvertex.setData(point.getX()); |
1378 |
DxfGroup yvertex = new DxfGroup();
|
1379 |
yvertex.setCode(20);
|
1380 |
yvertex.setData(point.getY()); |
1381 |
polv.add(xvertex); |
1382 |
polv.add(yvertex); |
1383 |
} |
1384 |
entityMaker.createLwPolyline(polv); |
1385 |
|
1386 |
} else {
|
1387 |
|
1388 |
polylineFlag.setData(flag|8);
|
1389 |
|
1390 |
DxfGroup xgroup = new DxfGroup();
|
1391 |
xgroup.setCode(10);
|
1392 |
xgroup.setData(0d);
|
1393 |
polv.add(xgroup); |
1394 |
DxfGroup ygroup = new DxfGroup();
|
1395 |
ygroup.setCode(20);
|
1396 |
ygroup.setData(0d);
|
1397 |
polv.add(ygroup); |
1398 |
DxfGroup elevation = new DxfGroup();
|
1399 |
elevation.setCode(30);
|
1400 |
elevation.setData(0d);
|
1401 |
polv.add(elevation); |
1402 |
DxfGroup subclassMarker = new DxfGroup(100, "AcDb3dPolyline"); |
1403 |
polv.add(subclassMarker); |
1404 |
|
1405 |
entityMaker.createPolyline(polv); |
1406 |
k++; |
1407 |
|
1408 |
|
1409 |
for (int i = 0; i < line.getNumVertices(); i++) { |
1410 |
org.gvsig.fmap.geom.primitive.Point point = line.get(i); |
1411 |
|
1412 |
DxfGroupVector verv = new DxfGroupVector();
|
1413 |
DxfGroup entityType = new DxfGroup(0, "VERTEX"); |
1414 |
verv.add(entityType); |
1415 |
DxfGroup generalSubclassMarker = new DxfGroup(100,"AcDbEntity"); |
1416 |
verv.add(generalSubclassMarker); |
1417 |
DxfGroup layerName = new DxfGroup(8, "default"); |
1418 |
verv.add(layerName); |
1419 |
DxfGroup vertexSubclassMarker = new DxfGroup(100,"AcDbVertex"); |
1420 |
verv.add(vertexSubclassMarker); |
1421 |
|
1422 |
DxfGroup xvertex = new DxfGroup();
|
1423 |
xvertex.setCode(10);
|
1424 |
xvertex.setData(point.getX()); |
1425 |
DxfGroup yvertex = new DxfGroup();
|
1426 |
yvertex.setCode(20);
|
1427 |
yvertex.setData(point.getY()); |
1428 |
DxfGroup zvertex = new DxfGroup();
|
1429 |
zvertex.setCode(20);
|
1430 |
zvertex.setData(point.getCoordinateAt(Geometry.DIMENSIONS.Z)); |
1431 |
verv.add(xvertex); |
1432 |
verv.add(yvertex); |
1433 |
verv.add(zvertex); |
1434 |
entityMaker.addVertex(verv); |
1435 |
k++; |
1436 |
} |
1437 |
// DxfGroupVector seqv = new DxfGroupVector();
|
1438 |
// DxfGroup entityType = new DxfGroup(0, "SEQEND");
|
1439 |
// seqv.add(entityType);
|
1440 |
// DxfGroup generalSubclassMarker = new DxfGroup(100, "AcDbEntity");
|
1441 |
// seqv.add(generalSubclassMarker);
|
1442 |
// DxfGroup layerName = new DxfGroup(8, "default");
|
1443 |
// seqv.add(layerName);
|
1444 |
// DxfGroup handleSeqGroup = new DxfGroup();
|
1445 |
// handleSeqGroup.setCode(5);
|
1446 |
// handleSeqGroup.setData(String.valueOf(handle + k));
|
1447 |
// seqv.add(handleSeqGroup);
|
1448 |
entityMaker.endSeq(); |
1449 |
k++; |
1450 |
|
1451 |
} |
1452 |
} |
1453 |
return k;
|
1454 |
} |
1455 |
|
1456 |
private int createPolyline3D_OLD(int handle, int k, FeatureProvider feature, |
1457 |
boolean isPolygon)
|
1458 |
throws Exception { |
1459 |
DxfGroupVector polv = updateProperties(feature, k); |
1460 |
Vector<org.gvsig.fmap.geom.primitive.Point> vpoints = new Vector<org.gvsig.fmap.geom.primitive.Point>(); |
1461 |
PathIterator theIterator = (feature.getDefaultGeometry())
|
1462 |
.getPathIterator(null, geomManager.getFlatness());
|
1463 |
double[] theData = new double[6]; |
1464 |
OrientablePrimitive curve = (OrientablePrimitive) feature.getDefaultGeometry(); |
1465 |
double[] velev = new double[curve.getNumVertices()]; |
1466 |
for (int i = 0; i < curve.getNumVertices(); i++) { |
1467 |
velev[i] = curve.getCoordinateAt(i, 2);
|
1468 |
} |
1469 |
|
1470 |
while (!theIterator.isDone()) {
|
1471 |
int theType = theIterator.currentSegment(theData);
|
1472 |
switch (theType) {
|
1473 |
case PathIterator.SEG_MOVETO: |
1474 |
vpoints.add(geomManager.createPoint(theData[0], theData[1], SUBTYPES.GEOM2D)); |
1475 |
break;
|
1476 |
case PathIterator.SEG_LINETO: |
1477 |
vpoints.add(geomManager.createPoint(theData[0], theData[1], SUBTYPES.GEOM2D)); |
1478 |
break;
|
1479 |
} |
1480 |
theIterator.next(); |
1481 |
} |
1482 |
if (constantElevation(velev)) {
|
1483 |
Integer flag = 0; |
1484 |
DxfGroup polylineFlag = new DxfGroup();
|
1485 |
polylineFlag.setCode(70);
|
1486 |
polylineFlag.setCode(70);
|
1487 |
if (isPolygon) {
|
1488 |
flag |= 1;
|
1489 |
} |
1490 |
polylineFlag.setData(flag); |
1491 |
polv.add(polylineFlag); |
1492 |
DxfGroup elevation = new DxfGroup();
|
1493 |
elevation.setCode(38);
|
1494 |
elevation.setData(new Double(velev[0])); |
1495 |
polv.add(elevation); |
1496 |
for (int j = 0; j < vpoints.size(); j++) { |
1497 |
DxfGroup xvertex = new DxfGroup();
|
1498 |
xvertex.setCode(10);
|
1499 |
xvertex.setData(new Double( |
1500 |
vpoints |
1501 |
.get(j).getX())); |
1502 |
DxfGroup yvertex = new DxfGroup();
|
1503 |
yvertex.setCode(20);
|
1504 |
yvertex.setData(new Double( |
1505 |
vpoints |
1506 |
.get(j).getY())); |
1507 |
polv.add(xvertex); |
1508 |
polv.add(yvertex); |
1509 |
} |
1510 |
entityMaker.createLwPolyline(polv); |
1511 |
k++; |
1512 |
} else {
|
1513 |
DxfGroup polylineFlag = new DxfGroup();
|
1514 |
polylineFlag.setCode(70);
|
1515 |
Integer flag = 8; |
1516 |
// polylineFlag.setData(new Integer(8));
|
1517 |
if (isPolygon) {
|
1518 |
flag |= 1;
|
1519 |
} |
1520 |
polylineFlag.setData(flag); |
1521 |
polv.add(polylineFlag); |
1522 |
DxfGroup xgroup = new DxfGroup();
|
1523 |
xgroup.setCode(10);
|
1524 |
xgroup.setData(new Double(0.0)); |
1525 |
polv.add(xgroup); |
1526 |
DxfGroup ygroup = new DxfGroup();
|
1527 |
ygroup.setCode(20);
|
1528 |
ygroup.setData(new Double(0.0)); |
1529 |
polv.add(ygroup); |
1530 |
DxfGroup elevation = new DxfGroup();
|
1531 |
elevation.setCode(30);
|
1532 |
elevation.setData(new Double(0.0)); |
1533 |
polv.add(elevation); |
1534 |
DxfGroup subclassMarker = new DxfGroup(100, "AcDb3dPolyline"); |
1535 |
polv.add(subclassMarker); |
1536 |
entityMaker.createPolyline(polv); |
1537 |
k++; |
1538 |
for (int j = 0; j < vpoints.size(); j++) { |
1539 |
DxfGroupVector verv = new DxfGroupVector();
|
1540 |
DxfGroup entityType = new DxfGroup(0, "VERTEX"); |
1541 |
verv.add(entityType); |
1542 |
DxfGroup generalSubclassMarker = new DxfGroup(100, |
1543 |
"AcDbEntity");
|
1544 |
verv.add(generalSubclassMarker); |
1545 |
DxfGroup layerName = new DxfGroup(8, "default"); |
1546 |
verv.add(layerName); |
1547 |
DxfGroup vertexSubclassMarker = new DxfGroup(100, |
1548 |
"AcDbVertex");
|
1549 |
verv.add(vertexSubclassMarker); |
1550 |
DxfGroup xvertex = new DxfGroup();
|
1551 |
xvertex.setCode(10);
|
1552 |
xvertex.setData(new Double( |
1553 |
vpoints |
1554 |
.get(j).getX())); |
1555 |
DxfGroup yvertex = new DxfGroup();
|
1556 |
yvertex.setCode(20);
|
1557 |
yvertex.setData(new Double( |
1558 |
vpoints |
1559 |
.get(j).getY())); |
1560 |
DxfGroup zvertex = new DxfGroup();
|
1561 |
zvertex.setCode(30);
|
1562 |
zvertex.setData(new Double(velev[j])); |
1563 |
verv.add(xvertex); |
1564 |
verv.add(yvertex); |
1565 |
verv.add(zvertex); |
1566 |
entityMaker.addVertex(verv); |
1567 |
k++; |
1568 |
} |
1569 |
DxfGroupVector seqv = new DxfGroupVector();
|
1570 |
DxfGroup entityType = new DxfGroup(0, "SEQEND"); |
1571 |
seqv.add(entityType); |
1572 |
DxfGroup generalSubclassMarker = new DxfGroup(100, "AcDbEntity"); |
1573 |
seqv.add(generalSubclassMarker); |
1574 |
DxfGroup layerName = new DxfGroup(8, "default"); |
1575 |
seqv.add(layerName); |
1576 |
DxfGroup handleSeqGroup = new DxfGroup();
|
1577 |
handleSeqGroup.setCode(5);
|
1578 |
handleSeqGroup.setData(new Integer(handle + k).toString()); |
1579 |
seqv.add(handleSeqGroup); |
1580 |
entityMaker.endSeq(); |
1581 |
k++; |
1582 |
} |
1583 |
return k;
|
1584 |
} |
1585 |
|
1586 |
private boolean constantElevation(Line line) { |
1587 |
Double elev = null; |
1588 |
for (org.gvsig.fmap.geom.primitive.Point point : line) {
|
1589 |
if(elev == null){ |
1590 |
elev = point.getCoordinateAt(Geometry.DIMENSIONS.Z); |
1591 |
continue;
|
1592 |
} |
1593 |
if (elev != point.getCoordinateAt(Geometry.DIMENSIONS.Z)) {
|
1594 |
return false; |
1595 |
} |
1596 |
} |
1597 |
return true; |
1598 |
} |
1599 |
|
1600 |
private boolean constantElevation(double[] velev) { |
1601 |
boolean constant = true; |
1602 |
for (int i = 0; i < velev.length; i++) { |
1603 |
for (int j = 0; j < velev.length; j++) { |
1604 |
if (j > i) {
|
1605 |
if (velev[i] != velev[j]) {
|
1606 |
constant = false;
|
1607 |
break;
|
1608 |
} |
1609 |
} |
1610 |
} |
1611 |
break;
|
1612 |
} |
1613 |
return constant;
|
1614 |
} |
1615 |
|
1616 |
private int createCircle2D(int handle, int k, FeatureProvider feature) |
1617 |
throws Exception { |
1618 |
DxfGroupVector polv = updateProperties(feature, k); |
1619 |
DxfGroup circleFlag = new DxfGroup();
|
1620 |
circleFlag.setCode(100);
|
1621 |
polv.add(circleFlag); |
1622 |
|
1623 |
DxfGroup xvertex = new DxfGroup();
|
1624 |
xvertex.setCode(10);
|
1625 |
Circle circle = (Circle) (feature |
1626 |
.getDefaultGeometry()); |
1627 |
xvertex.setData(new Double(circle.getCenter().getX())); |
1628 |
DxfGroup yvertex = new DxfGroup();
|
1629 |
yvertex.setCode(20);
|
1630 |
yvertex.setData(new Double(circle.getCenter().getY())); |
1631 |
DxfGroup zvertex = new DxfGroup();
|
1632 |
zvertex.setCode(30);
|
1633 |
// TODO: COORDENADA Z. REVISAR ESTO PARA ENTIDADES 3D
|
1634 |
zvertex.setData(new Double(0)); |
1635 |
|
1636 |
DxfGroup radius = new DxfGroup();
|
1637 |
radius.setCode(40);
|
1638 |
radius.setData(new Double(circle.getRadious())); |
1639 |
|
1640 |
polv.add(xvertex); |
1641 |
polv.add(yvertex); |
1642 |
polv.add(zvertex); |
1643 |
polv.add(radius); |
1644 |
|
1645 |
entityMaker.createCircle(polv); |
1646 |
k++; |
1647 |
return k;
|
1648 |
} |
1649 |
|
1650 |
private int createArc2D(int handle, int k, FeatureProvider feature) |
1651 |
throws Exception { |
1652 |
Arc arc = (Arc) (feature.getDefaultGeometry()); |
1653 |
|
1654 |
org.gvsig.fmap.geom.primitive.Point[] pts = new org.gvsig.fmap.geom.primitive.Point[3]; |
1655 |
pts[0] = arc.getInitPoint();
|
1656 |
pts[1] = arc.getMiddlePoint();
|
1657 |
pts[2] = arc.getEndPoint();
|
1658 |
org.gvsig.fmap.geom.primitive.Point center = arc.getCenterPoint(); |
1659 |
GeometryOperationContext ctx = new GeometryOperationContext();
|
1660 |
ctx.setAttribute("geom", pts[0]); |
1661 |
double radius = ((Double)geomManager.invokeOperation(PointDistance.CODE, center, ctx)).doubleValue(); |
1662 |
|
1663 |
double initAngle = ((Double)geomManager.invokeOperation(PointGetAngle.CODE, center, ctx)).doubleValue(); |
1664 |
initAngle = Math.toDegrees(initAngle);
|
1665 |
ctx.setAttribute("geom", pts[1]); |
1666 |
double midAngle = ((Double)geomManager.invokeOperation(PointGetAngle.CODE, center, ctx)).doubleValue(); |
1667 |
midAngle = Math.toDegrees(midAngle);
|
1668 |
ctx.setAttribute("geom", pts[2]); |
1669 |
double endAngle = ((Double)geomManager.invokeOperation(PointGetAngle.CODE, center, ctx)).doubleValue(); |
1670 |
endAngle = Math.toDegrees(endAngle);
|
1671 |
|
1672 |
double aux;
|
1673 |
if(initAngle<=endAngle){
|
1674 |
if(initAngle<=midAngle && midAngle<=endAngle){
|
1675 |
//do nothing
|
1676 |
} else {
|
1677 |
aux = initAngle; |
1678 |
initAngle = endAngle; |
1679 |
endAngle = aux; |
1680 |
} |
1681 |
} else {
|
1682 |
if(initAngle>=midAngle && midAngle>=endAngle){
|
1683 |
aux = initAngle; |
1684 |
initAngle = endAngle; |
1685 |
endAngle = aux; |
1686 |
} else {
|
1687 |
//do nothing
|
1688 |
} |
1689 |
} |
1690 |
|
1691 |
DxfGroup ax = new DxfGroup();
|
1692 |
DxfGroup ay = new DxfGroup();
|
1693 |
DxfGroup ac = new DxfGroup();
|
1694 |
DxfGroup ai = new DxfGroup();
|
1695 |
DxfGroup ae = new DxfGroup();
|
1696 |
ax.setCode(10);
|
1697 |
ax.setData(new Double(center.getX())); |
1698 |
ay.setCode(20);
|
1699 |
ay.setData(new Double(center.getY())); |
1700 |
ac.setCode(40);
|
1701 |
ac.setData(new Double(radius)); |
1702 |
ai.setCode(50);
|
1703 |
ai.setData(new Double(initAngle)); |
1704 |
ae.setCode(51);
|
1705 |
ae.setData(new Double(endAngle)); |
1706 |
DxfGroupVector av = updateProperties(feature, k); |
1707 |
av.add(ax); |
1708 |
av.add(ay); |
1709 |
av.add(ac); |
1710 |
av.add(ai); |
1711 |
av.add(ae); |
1712 |
entityMaker.createArc(av); |
1713 |
k++; |
1714 |
return k;
|
1715 |
} |
1716 |
|
1717 |
private int createEllipse2D(int handle, int k, FeatureProvider feature) |
1718 |
throws Exception { |
1719 |
Ellipse ellipse = (Ellipse) (feature |
1720 |
.getDefaultGeometry()); |
1721 |
|
1722 |
org.gvsig.fmap.geom.primitive.Point center = (org.gvsig.fmap.geom.primitive.Point)geomManager.create(TYPES.POINT, SUBTYPES.GEOM2D); |
1723 |
center.setCoordinateAt(0, (ellipse.getAxis1Start().getX() + ellipse.getAxis1End().getX()) / 2); |
1724 |
center.setCoordinateAt(1, (ellipse.getAxis1Start().getY() + ellipse.getAxis1End().getY()) / 2); |
1725 |
|
1726 |
double mAxisL = ellipse.getAxis2Dist() * 2; |
1727 |
GeometryOperationContext ctx = new GeometryOperationContext();
|
1728 |
ctx.setAttribute("geom", ellipse.getAxis1End());
|
1729 |
double maAxisL = ((Double)geomManager.invokeOperation(PointDistance.CODE, ellipse.getAxis1Start(), ctx)).doubleValue(); |
1730 |
|
1731 |
Point2D endPointOfMajorAxis = new Point2D.Double(ellipse.getAxis1End().getX(), ellipse.getAxis1End().getY()); |
1732 |
double azimut = Math |
1733 |
.atan2(endPointOfMajorAxis.getX() - center.getX(), |
1734 |
endPointOfMajorAxis.getY() - center.getY()); |
1735 |
double azimut2 = azimut + Math.PI / 2.0; |
1736 |
if (azimut2 >= Math.PI * 2) { |
1737 |
azimut2 = azimut2 - Math.PI * 2; |
1738 |
} |
1739 |
Point2D endPointOfMinorAxis = new Point2D.Double(center.getX() |
1740 |
+ (ellipse.getAxis2Dist() * Math.sin(azimut2)), center.getY()
|
1741 |
+ (ellipse.getAxis2Dist() * Math.cos(azimut2)));
|
1742 |
|
1743 |
if (mAxisL >= maAxisL) {
|
1744 |
// El menor debe ser menor que el mayor. Los cambiamos.
|
1745 |
double aux = mAxisL;
|
1746 |
mAxisL = maAxisL; |
1747 |
maAxisL = aux; |
1748 |
// Tambi�n cambiamos los puntos finales de los ejes.
|
1749 |
Point2D pAux = endPointOfMinorAxis;
|
1750 |
endPointOfMinorAxis = endPointOfMajorAxis; |
1751 |
endPointOfMajorAxis = pAux; |
1752 |
} |
1753 |
double mToMAR = mAxisL / maAxisL;
|
1754 |
DxfGroup x = new DxfGroup();
|
1755 |
DxfGroup y = new DxfGroup();
|
1756 |
DxfGroup xc = new DxfGroup();
|
1757 |
DxfGroup yc = new DxfGroup();
|
1758 |
DxfGroup minToMaj = new DxfGroup();
|
1759 |
x.setCode(10);
|
1760 |
x.setData(new Double(center.getX())); |
1761 |
y.setCode(20);
|
1762 |
y.setData(new Double(center.getY())); |
1763 |
xc.setCode(11);
|
1764 |
xc.setData(new Double(endPointOfMajorAxis.getX() - center.getX())); |
1765 |
yc.setCode(21);
|
1766 |
yc.setData(new Double(endPointOfMajorAxis.getY() - center.getY())); |
1767 |
minToMaj.setCode(40);
|
1768 |
minToMaj.setData(new Double(mToMAR)); |
1769 |
DxfGroupVector av = updateProperties(feature, k); |
1770 |
av.add(x); |
1771 |
av.add(y); |
1772 |
av.add(xc); |
1773 |
av.add(yc); |
1774 |
av.add(minToMaj); |
1775 |
entityMaker.createEllipse(av); |
1776 |
k++; |
1777 |
return k;
|
1778 |
} |
1779 |
|
1780 |
/**
|
1781 |
* @return the envelope
|
1782 |
*/
|
1783 |
public Envelope getEnvelope() {
|
1784 |
return this.envelope; |
1785 |
} |
1786 |
|
1787 |
} |
1788 |
|
1789 |
public boolean closeResourceRequested(ResourceProvider resource) { |
1790 |
return true; |
1791 |
} |
1792 |
|
1793 |
public int getOIDType() { |
1794 |
return DataTypes.LONG;
|
1795 |
} |
1796 |
|
1797 |
public boolean supportsAppendMode() { |
1798 |
return false; |
1799 |
} |
1800 |
|
1801 |
public void append(FeatureProvider featureProvider) { |
1802 |
try {
|
1803 |
writer.add(featureProvider); |
1804 |
} catch (WriteException e) {
|
1805 |
// TODO Auto-generated catch block
|
1806 |
e.printStackTrace(); |
1807 |
} |
1808 |
} |
1809 |
|
1810 |
public void beginAppend() { |
1811 |
try {
|
1812 |
writer = new Writer().initialice((File) resource.get(), projection); |
1813 |
writer.begin(); |
1814 |
} catch (AccessResourceException e) {
|
1815 |
// TODO Auto-generated catch block
|
1816 |
e.printStackTrace(); |
1817 |
} |
1818 |
} |
1819 |
|
1820 |
public void endAppend() { |
1821 |
try {
|
1822 |
resource.notifyOpen(); |
1823 |
writer.end(); |
1824 |
resource.notifyClose(); |
1825 |
counterNewsOIDs = 0;
|
1826 |
} catch (ResourceNotifyOpenException e) {
|
1827 |
// TODO Auto-generated catch block
|
1828 |
e.printStackTrace(); |
1829 |
} catch (ResourceNotifyCloseException e) {
|
1830 |
// TODO Auto-generated catch block
|
1831 |
e.printStackTrace(); |
1832 |
} catch (WriteException e) {
|
1833 |
// TODO Auto-generated catch block
|
1834 |
e.printStackTrace(); |
1835 |
} |
1836 |
} |
1837 |
|
1838 |
/**
|
1839 |
* @param state
|
1840 |
* @throws PersistenceException
|
1841 |
*/
|
1842 |
public void saveToState(PersistentState state) throws PersistenceException { |
1843 |
// TODO Auto-generated method stub
|
1844 |
throw new NotYetImplemented(); |
1845 |
} |
1846 |
|
1847 |
/**
|
1848 |
* @param state
|
1849 |
* @throws PersistenceException
|
1850 |
*/
|
1851 |
public void loadFromState(PersistentState state) throws PersistenceException { |
1852 |
// TODO Auto-generated method stub
|
1853 |
throw new NotYetImplemented(); |
1854 |
} |
1855 |
|
1856 |
public Object createNewOID() { |
1857 |
return new Long(counterNewsOIDs++); |
1858 |
} |
1859 |
|
1860 |
protected void initializeFeatureTypes() throws InitializeException { |
1861 |
try {
|
1862 |
this.open();
|
1863 |
} catch (OpenException e) {
|
1864 |
throw new InitializeException(this.getProviderName(), e); |
1865 |
} |
1866 |
} |
1867 |
|
1868 |
public Envelope getEnvelope() throws DataException { |
1869 |
this.open();
|
1870 |
return this.envelope; |
1871 |
} |
1872 |
|
1873 |
public Object getDynValue(String name) throws DynFieldNotFoundException { |
1874 |
if( DataStore.METADATA_ENVELOPE.equalsIgnoreCase(name) ) {
|
1875 |
try {
|
1876 |
return this.getEnvelope(); |
1877 |
} catch (DataException e) {
|
1878 |
return null; |
1879 |
} |
1880 |
} else {
|
1881 |
if( DataStore.METADATA_CRS.equalsIgnoreCase(name) ) {
|
1882 |
IProjection pro = this.getDXFParameters().getCRS();
|
1883 |
if (pro != null){ |
1884 |
return pro;
|
1885 |
} |
1886 |
} |
1887 |
} |
1888 |
return super.getDynValue(name); |
1889 |
} |
1890 |
|
1891 |
|
1892 |
/*
|
1893 |
* (non-Javadoc)
|
1894 |
*
|
1895 |
* @see
|
1896 |
* org.gvsig.fmap.dal.resource.spi.ResourceConsumer#resourceChanged(org.
|
1897 |
* gvsig.fmap.dal.resource.spi.ResourceProvider)
|
1898 |
*/
|
1899 |
public void resourceChanged(ResourceProvider resource) { |
1900 |
this.getStoreServices().notifyChange(
|
1901 |
DataStoreNotification.RESOURCE_CHANGED, |
1902 |
resource); |
1903 |
} |
1904 |
|
1905 |
|
1906 |
public Object getSourceId() { |
1907 |
return this.getDXFParameters().getFile(); |
1908 |
} |
1909 |
|
1910 |
public String getName() { |
1911 |
String name = this.getDXFParameters().getFile().getName(); |
1912 |
|
1913 |
return FilenameUtils.getBaseName(name);
|
1914 |
} |
1915 |
|
1916 |
public String getFullName() { |
1917 |
return this.getDXFParameters().getFile().getAbsolutePath(); |
1918 |
} |
1919 |
|
1920 |
public ResourceProvider getResource() {
|
1921 |
return resource;
|
1922 |
} |
1923 |
|
1924 |
/* (non-Javadoc)
|
1925 |
* @see org.gvsig.fmap.dal.feature.spi.memory.AbstractMemoryStoreProvider#doDispose()
|
1926 |
*/
|
1927 |
@Override
|
1928 |
protected void doDispose() throws BaseException { |
1929 |
super.doDispose();
|
1930 |
resource.removeConsumer(this);
|
1931 |
} |
1932 |
|
1933 |
} |