gvsig-3d / 1.10 / trunk / libraries / lib3DMap / src / org / gvsig / gvsig3d / map3d / MapContext3D.java @ 113
History | View | Annotate | Download (42.2 KB)
1 | 5 | jzarzoso | package org.gvsig.gvsig3d.map3d; |
---|---|---|---|
2 | |||
3 | import java.awt.Dimension; |
||
4 | import java.awt.Graphics2D; |
||
5 | import java.awt.Point; |
||
6 | import java.awt.geom.AffineTransform; |
||
7 | import java.awt.geom.Rectangle2D; |
||
8 | import java.awt.image.BufferedImage; |
||
9 | import java.awt.image.ImagingOpException; |
||
10 | import java.awt.image.RenderedImage; |
||
11 | import java.io.File; |
||
12 | import java.io.IOException; |
||
13 | 91 | rgaitan | import java.util.ArrayList; |
14 | 5 | jzarzoso | import java.util.Hashtable; |
15 | import java.util.Vector; |
||
16 | |||
17 | import javax.print.attribute.PrintRequestAttributeSet; |
||
18 | |||
19 | import org.apache.log4j.Logger; |
||
20 | import org.cresques.cts.IProjection; |
||
21 | import org.gvsig.cacheservice.TileNum; |
||
22 | 91 | rgaitan | import org.gvsig.fmap.raster.layers.FLyrRasterSE; |
23 | 5 | jzarzoso | import org.gvsig.gvsig3d.cacheservices.FLayerCacheService; |
24 | import org.gvsig.gvsig3d.cacheservices.OSGCacheService; |
||
25 | import org.gvsig.gvsig3d.cacheservices.VectorCacheService; |
||
26 | import org.gvsig.gvsig3d.drivers.GvsigDriverOSG; |
||
27 | import org.gvsig.gvsig3d.map3d.layers.FLayers3D; |
||
28 | import org.gvsig.osgvp.core.osg.Image; |
||
29 | import org.gvsig.osgvp.core.osg.Matrix; |
||
30 | import org.gvsig.osgvp.core.osg.Node; |
||
31 | import org.gvsig.osgvp.core.osg.Vec3; |
||
32 | import org.gvsig.osgvp.core.osg.Vec4; |
||
33 | import org.gvsig.osgvp.exceptions.image.ImageConversionException; |
||
34 | import org.gvsig.osgvp.exceptions.node.ChildIndexOutOfBoundsExceptions; |
||
35 | import org.gvsig.osgvp.exceptions.node.NodeException; |
||
36 | import org.gvsig.osgvp.terrain.DataLoader; |
||
37 | import org.gvsig.osgvp.terrain.Extent; |
||
38 | import org.gvsig.osgvp.terrain.HeightfieldLayer; |
||
39 | import org.gvsig.osgvp.terrain.JavaDataDriver; |
||
40 | import org.gvsig.osgvp.terrain.Layer; |
||
41 | import org.gvsig.osgvp.terrain.LayerManager; |
||
42 | import org.gvsig.osgvp.terrain.RasterLayer; |
||
43 | import org.gvsig.osgvp.terrain.RequestDataEvent; |
||
44 | import org.gvsig.osgvp.terrain.Terrain; |
||
45 | import org.gvsig.osgvp.terrain.TerrainViewer; |
||
46 | import org.gvsig.osgvp.terrain.UpdateDataEvent; |
||
47 | import org.gvsig.osgvp.terrain.VectorLayer; |
||
48 | import org.gvsig.osgvp.terrain.Terrain.CoordinateSystemType; |
||
49 | import org.gvsig.osgvp.terrain.exceptions.LayerManagementException; |
||
50 | import org.gvsig.osgvp.viewer.Camera; |
||
51 | import org.gvsig.osgvp.viewer.IViewerContainer; |
||
52 | import org.gvsig.osgvp.viewer.PrintUtilities; |
||
53 | |||
54 | import com.hardcode.driverManager.Driver; |
||
55 | import com.hardcode.gdbms.driver.exceptions.ReadDriverException; |
||
56 | import com.iver.ai2.gvsig3d.map3d.layers.Layer3DProps; |
||
57 | import com.iver.andami.PluginServices; |
||
58 | import com.iver.andami.messages.NotificationManager; |
||
59 | import com.iver.andami.ui.mdiManager.IWindow; |
||
60 | import com.iver.cit.gvsig.exceptions.expansionfile.ExpansionFileReadException; |
||
61 | import com.iver.cit.gvsig.fmap.MapContext; |
||
62 | import com.iver.cit.gvsig.fmap.ViewPort; |
||
63 | import com.iver.cit.gvsig.fmap.layers.FBitSet; |
||
64 | import com.iver.cit.gvsig.fmap.layers.FLayer; |
||
65 | import com.iver.cit.gvsig.fmap.layers.FLayers; |
||
66 | import com.iver.cit.gvsig.fmap.layers.FLyrDefault; |
||
67 | import com.iver.cit.gvsig.fmap.layers.FLyrVect; |
||
68 | import com.iver.cit.gvsig.fmap.layers.FLyrWCS; |
||
69 | import com.iver.cit.gvsig.fmap.layers.GraphicLayer; |
||
70 | import com.iver.cit.gvsig.fmap.layers.LayerEvent; |
||
71 | import com.iver.cit.gvsig.fmap.layers.LayerListener; |
||
72 | import com.iver.cit.gvsig.fmap.layers.LegendChangedEvent; |
||
73 | import com.iver.cit.gvsig.fmap.layers.SelectableDataSource; |
||
74 | import com.iver.cit.gvsig.fmap.layers.SelectionEvent; |
||
75 | import com.iver.cit.gvsig.fmap.layers.SelectionListener; |
||
76 | import com.iver.cit.gvsig.fmap.layers.SelectionSupport; |
||
77 | import com.iver.cit.gvsig.fmap.layers.SingleLayerIterator; |
||
78 | import com.iver.cit.gvsig.fmap.layers.XMLException; |
||
79 | import com.iver.cit.gvsig.fmap.layers.layerOperations.Classifiable; |
||
80 | import com.iver.cit.gvsig.fmap.rendering.LegendListener; |
||
81 | import com.iver.cit.gvsig.project.documents.view.gui.BaseView; |
||
82 | import com.iver.utiles.XMLEntity; |
||
83 | import com.iver.utiles.swing.threads.Cancellable; |
||
84 | |||
85 | public class MapContext3D extends MapContext implements DataLoader, |
||
86 | 9 | jzarzoso | LayerListener, LegendListener, SelectionListener { |
87 | 5 | jzarzoso | |
88 | // JOSG library objects
|
||
89 | private Terrain _terrain;
|
||
90 | private IViewerContainer _canvas3d;
|
||
91 | private TerrainViewer _terrainViewer;
|
||
92 | private LayerManager _terrainLayerManager;
|
||
93 | private JavaDataDriver _terrainDataManager = null; |
||
94 | |||
95 | private Hashtable<FLayer, Layer> _terrainFLayerMap = new Hashtable<FLayer, Layer>(); |
||
96 | private Hashtable<String, FLayer> _terrainLayerMap = new Hashtable<String, FLayer>(); |
||
97 | |||
98 | private IProjection _viewProjection;
|
||
99 | private float _verticalExaggeration; |
||
100 | private boolean _bEmptyView = true; |
||
101 | private boolean _bListenToLegend = true; |
||
102 | private boolean _bLoading = false; |
||
103 | private TerrainViewer _canvasoff = null; |
||
104 | private boolean _renewCanvasOff = false; |
||
105 | private static Logger _logger = Logger.getLogger(MapContext3D.class |
||
106 | .getName()); |
||
107 | TerrainViewer _printViewer = null;
|
||
108 | Layer _testRasterLayer = null;
|
||
109 | |||
110 | private boolean visibilityChange = false; |
||
111 | |||
112 | @Override
|
||
113 | public void draw(BufferedImage image, Graphics2D g, Cancellable cancel, |
||
114 | double scale) throws ReadDriverException { |
||
115 | |||
116 | if(_canvas3d == null || _canvas3d.getOSGViewer() == null) return; |
||
117 | double x = getViewPort().getOffset().getX();
|
||
118 | double y = getViewPort().getOffset().getY();
|
||
119 | double w = image.getWidth();
|
||
120 | double h = image.getHeight();
|
||
121 | |||
122 | if (_canvasoff == null) { |
||
123 | try {
|
||
124 | _canvasoff = new TerrainViewer();
|
||
125 | _canvasoff.setUpViewerInBackground(0, 0, 512, 512); |
||
126 | |||
127 | Terrain planetView3D = ((TerrainViewer) _canvas3d |
||
128 | .getOSGViewer()).getTerrain(0);
|
||
129 | Terrain terrain = new Terrain();
|
||
130 | terrain.setCoordinateSystemType(planetView3D |
||
131 | .getCoordinateSystemType()); |
||
132 | terrain.setCoordinateSystemName(planetView3D |
||
133 | .getCoordinateSystemName()); |
||
134 | terrain.setCoordinateSystemFormat(planetView3D |
||
135 | .getCoordinateSystemFormat()); |
||
136 | terrain.setExtent(planetView3D.getExtent()); |
||
137 | terrain.setTerrainName(planetView3D.getTerrainName()); |
||
138 | |||
139 | terrain.init(); |
||
140 | terrain.setLayerManager(_terrainLayerManager); |
||
141 | |||
142 | _canvasoff.addTerrain(terrain); |
||
143 | _canvasoff.addFeature((((TerrainViewer) _canvas3d |
||
144 | .getOSGViewer()).getFeatures())); |
||
145 | Vec4 color = ((TerrainViewer) _canvas3d.getOSGViewer()) |
||
146 | 9 | jzarzoso | .getClearColor(); |
147 | 5 | jzarzoso | _canvasoff.setClearColor(color.x(), color.y(), color.z(), color |
148 | .w()); |
||
149 | this.setRenewCanvasOff(false); |
||
150 | } catch (NodeException e) {
|
||
151 | // TODO Auto-generated catch block
|
||
152 | e.printStackTrace(); |
||
153 | } |
||
154 | |||
155 | } |
||
156 | |||
157 | Camera refCam = _canvas3d.getOSGViewer().getCamera(); |
||
158 | Matrix refView = refCam.getViewMatrix(); |
||
159 | Matrix refProy = refCam.getProjectionMatrix(); |
||
160 | Matrix.Perspective pers = refProy.getPerspective(); |
||
161 | Camera viewCam = new Camera();
|
||
162 | viewCam.setProjectionMatrixAsPerspective(pers.fovy, w / h, pers.zNear, |
||
163 | pers.zFar); |
||
164 | viewCam.setViewMatrix(refView); |
||
165 | _canvasoff.setViewport(0, 0, (int) w, (int) h); |
||
166 | _canvasoff.setCamera(viewCam); |
||
167 | _canvasoff.takeScreenshotToMemory(); |
||
168 | _canvasoff.frame(); |
||
169 | |||
170 | Image OSGimage = _canvasoff.getScreenshotImage();
|
||
171 | |||
172 | BufferedImage img = null; |
||
173 | try {
|
||
174 | img = OSGimage.getBufferedImage(); |
||
175 | } catch (ImageConversionException e1) {
|
||
176 | // TODO Auto-generated catch block
|
||
177 | e1.printStackTrace(); |
||
178 | } catch (IOException e1) { |
||
179 | // TODO Auto-generated catch block
|
||
180 | e1.printStackTrace(); |
||
181 | } |
||
182 | |||
183 | double scalex = w / img.getWidth(null); |
||
184 | double scaley = h / img.getHeight(null); |
||
185 | try {
|
||
186 | AffineTransform xform = AffineTransform.getScaleInstance(scalex, |
||
187 | scaley); |
||
188 | AffineTransform xpos = AffineTransform.getTranslateInstance(x, y); |
||
189 | xpos.concatenate(xform); |
||
190 | g.drawRenderedImage(img, xpos); |
||
191 | } catch (ImagingOpException e) { |
||
192 | NotificationManager.addError("Dibujando FFramePicture", e);
|
||
193 | } |
||
194 | |||
195 | } |
||
196 | |||
197 | public void print(Graphics2D g, double scale, PrintRequestAttributeSet arg2) |
||
198 | 9 | jzarzoso | throws ReadDriverException {
|
199 | 5 | jzarzoso | |
200 | int x = (int) getViewPort().getOffset().getX(); |
||
201 | int y = (int) getViewPort().getOffset().getY(); |
||
202 | int w = (int) g.getClipBounds().getWidth(); |
||
203 | int h = (int) g.getClipBounds().getHeight(); |
||
204 | System.err.println("x " + x + "; y " + y + "; w " + w + "; h" + h); |
||
205 | |||
206 | Camera viewerCam = _canvas3d.getOSGViewer().getCamera(); |
||
207 | BufferedImage s = null; |
||
208 | |||
209 | try {
|
||
210 | int minw = (int) w / 10; |
||
211 | int minh = (int) h / 10; |
||
212 | System.out.println("minw" + minw + " minh" + minh); |
||
213 | |||
214 | _printViewer = new TerrainViewer();
|
||
215 | // Terrain planetView3D = ((TerrainViewer)
|
||
216 | // _canvas3d.getOSGViewer()).getTerrain(0);
|
||
217 | // Terrain terrain = new Terrain();
|
||
218 | // terrain.setCoordinateSystemType(planetView3D
|
||
219 | // .getCoordinateSystemType());
|
||
220 | // terrain.setCoordinateSystemName(planetView3D
|
||
221 | // .getCoordinateSystemName());
|
||
222 | // terrain.setCoordinateSystemFormat(planetView3D
|
||
223 | // .getCoordinateSystemFormat());
|
||
224 | // terrain.setExtent(planetView3D.getExtent());
|
||
225 | // terrain.setTerrainName(planetView3D.getTerrainName());
|
||
226 | //
|
||
227 | //
|
||
228 | // terrain.init();
|
||
229 | // terrain.setLayerManager(_terrainLayerManager);
|
||
230 | |||
231 | _printViewer.addTerrain((((TerrainViewer) _canvas3d.getOSGViewer()) |
||
232 | .getTerrain(0)));
|
||
233 | _printViewer.addFeature((((TerrainViewer) _canvas3d.getOSGViewer()) |
||
234 | .getFeatures())); |
||
235 | Vec4 color = ((TerrainViewer) _canvas3d.getOSGViewer()) |
||
236 | 9 | jzarzoso | .getClearColor(); |
237 | 5 | jzarzoso | _printViewer.setClearColor(color.x(), color.y(), color.z(), color |
238 | .w()); |
||
239 | _printViewer.setUpViewerInBackground(0, 0, minw, minh); |
||
240 | |||
241 | PrintUtilities util = new PrintUtilities();
|
||
242 | util.setViewer(_printViewer); |
||
243 | s = util.getHighResolutionImage(viewerCam, w, h, |
||
244 | new PrintUtilities.FrameFinishedListener() {
|
||
245 | |||
246 | 9 | jzarzoso | public boolean isframeFinished() { |
247 | /*if (getDataManager().getNumPendingRequests() > 0) {
|
||
248 | 5 | jzarzoso | System.out.println("getNumPending:" + getDataManager().getNumPendingRequests());
|
249 | return false;
|
||
250 | }
|
||
251 | System.out.println("------------------ OLE! -------------");*/
|
||
252 | 9 | jzarzoso | return true; |
253 | } |
||
254 | }); |
||
255 | 5 | jzarzoso | |
256 | RenderedImage render = s;
|
||
257 | } catch (NodeException e1) {
|
||
258 | // TODO Auto-generated catch block
|
||
259 | e1.printStackTrace(); |
||
260 | } |
||
261 | |||
262 | double scalex = w / s.getWidth(null); |
||
263 | double scaley = h / s.getHeight(null); |
||
264 | try {
|
||
265 | AffineTransform xform = AffineTransform.getScaleInstance(scalex, |
||
266 | scaley); |
||
267 | AffineTransform xpos = AffineTransform.getTranslateInstance(x, y); |
||
268 | xpos.concatenate(xform); |
||
269 | g.drawRenderedImage(s, xpos); |
||
270 | // g.drawRenderedImage(img, new AffineTransform());
|
||
271 | } catch (ImagingOpException e) { |
||
272 | NotificationManager.addError("Dibujando FFramePicture", e);
|
||
273 | } |
||
274 | _printViewer.releaseGLContext(); |
||
275 | _printViewer.dispose(); |
||
276 | System.gc();
|
||
277 | } |
||
278 | |||
279 | public MapContext3D(ViewPort vp) {
|
||
280 | super(vp);
|
||
281 | } |
||
282 | |||
283 | public MapContext3D(FLayers fLayers, ViewPort vp) {
|
||
284 | super(fLayers, vp);
|
||
285 | } |
||
286 | |||
287 | public void setTerrain(Terrain terrain) { |
||
288 | if (_terrain == terrain)
|
||
289 | return;
|
||
290 | |||
291 | _terrain = terrain; |
||
292 | |||
293 | // add layers to terrain necessary when we are loading
|
||
294 | addCurrentLayers(); |
||
295 | } |
||
296 | |||
297 | public Terrain getTerrain() {
|
||
298 | return _terrain;
|
||
299 | } |
||
300 | |||
301 | public void setDataManager(JavaDataDriver manager) { |
||
302 | _terrainDataManager = manager; |
||
303 | _terrainDataManager.setDataLoader(this);
|
||
304 | } |
||
305 | |||
306 | public JavaDataDriver getDataManager() {
|
||
307 | return _terrainDataManager;
|
||
308 | } |
||
309 | |||
310 | public void setLayerManager(LayerManager manager) { |
||
311 | _terrainLayerManager = manager; |
||
312 | } |
||
313 | |||
314 | public LayerManager getLayerManager() {
|
||
315 | return _terrainLayerManager;
|
||
316 | } |
||
317 | |||
318 | public void setViewer(IViewerContainer canvas) { |
||
319 | _canvas3d = canvas; |
||
320 | _terrainViewer = (TerrainViewer) _canvas3d.getOSGViewer(); |
||
321 | } |
||
322 | |||
323 | public IProjection getViewProjection() {
|
||
324 | return _viewProjection;
|
||
325 | } |
||
326 | |||
327 | public void setViewProjection(IProjection projection) { |
||
328 | _viewProjection = projection; |
||
329 | } |
||
330 | |||
331 | public IViewerContainer getCanvas3d() {
|
||
332 | return _canvas3d;
|
||
333 | } |
||
334 | |||
335 | public float getVerticalExaggeration() { |
||
336 | return _verticalExaggeration;
|
||
337 | } |
||
338 | |||
339 | public void setVerticalExaggeration(float verticalExaggeration) { |
||
340 | _verticalExaggeration = verticalExaggeration; |
||
341 | } |
||
342 | |||
343 | public void setLoading(boolean bLoading) { |
||
344 | _bLoading = bLoading; |
||
345 | } |
||
346 | |||
347 | public FLayers getNewGroupLayer(FLayers parent) {
|
||
348 | return new FLayers3D(this, parent, getViewPort()); |
||
349 | } |
||
350 | |||
351 | /** * LAYER CHANGES called by FLayers3D ** */
|
||
352 | |||
353 | public void layerMoved(FLayers3D parent, FLayer layer, |
||
354 | int oldPos, int newPos) { |
||
355 | |||
356 | if (layer instanceof FLayers) { |
||
357 | FLayers group = (FLayers) layer; |
||
358 | if (newPos > oldPos) {
|
||
359 | for (int iChild = group.getLayersCount() - 1; iChild >= 0; iChild--) |
||
360 | layerMoved((FLayers3D) group, group.getLayer(iChild), |
||
361 | oldPos, newPos); |
||
362 | } else {
|
||
363 | for (int iChild = 0; iChild < group.getLayersCount(); iChild++) |
||
364 | layerMoved((FLayers3D) group, group.getLayer(iChild), |
||
365 | oldPos, newPos); |
||
366 | } |
||
367 | return;
|
||
368 | } |
||
369 | |||
370 | Layer3DProps props3D = getLayer3DProps(layer); |
||
371 | int type = props3D.getType();
|
||
372 | |||
373 | // Now reorder in layer manager only for terrain layer types
|
||
374 | if ((type == Layer3DProps.layer3DOSG)
|
||
375 | || ((type == Layer3DProps.layer3DVector))) |
||
376 | return;
|
||
377 | |||
378 | // Obtain the old position in the layer
|
||
379 | Layer terrainLayer = _terrainFLayerMap.get(layer); |
||
380 | Vector<Integer> terrainOldPos=null; |
||
381 | try {
|
||
382 | terrainOldPos = _terrainLayerManager |
||
383 | 9 | jzarzoso | .getOrder(terrainLayer); |
384 | 5 | jzarzoso | } catch (LayerManagementException e) {
|
385 | // TODO Auto-generated catch block
|
||
386 | e.printStackTrace(); |
||
387 | } |
||
388 | |||
389 | int terrainNewPos = 0; |
||
390 | // Compute the new position.
|
||
391 | SingleLayerIterator lyrIterator = new SingleLayerIterator(layers);
|
||
392 | while (lyrIterator.hasNext()) {
|
||
393 | FLayer auxLayer = lyrIterator.next(); |
||
394 | if (auxLayer == layer)
|
||
395 | break;
|
||
396 | Layer3DProps auxProps3D = getLayer3DProps(auxLayer); |
||
397 | if ((auxProps3D.getType() != Layer3DProps.layer3DOSG)
|
||
398 | && (auxProps3D.getType() != Layer3DProps.layer3DVector)) { |
||
399 | terrainNewPos++; |
||
400 | } |
||
401 | |||
402 | } |
||
403 | |||
404 | if ((terrainOldPos == null) || (terrainOldPos.size() == 0)) |
||
405 | return;
|
||
406 | if (terrainOldPos.get(0) != terrainNewPos) |
||
407 | try {
|
||
408 | _terrainLayerManager.moveLayer(terrainOldPos.get(0), terrainNewPos);
|
||
409 | } catch (LayerManagementException e) {
|
||
410 | // TODO Auto-generated catch block
|
||
411 | e.printStackTrace(); |
||
412 | } |
||
413 | |||
414 | 9 | jzarzoso | System.out.println("En el toc antes era el " + oldPos + " y ahora el " |
415 | + newPos); |
||
416 | System.out.println("En el terrain antes era el " + terrainOldPos |
||
417 | + " y ahora el " + terrainNewPos);
|
||
418 | 5 | jzarzoso | |
419 | 9 | jzarzoso | PrintDebugLayers(); |
420 | 5 | jzarzoso | } |
421 | |||
422 | public void layerAdded(FLayers3D parent, FLayer layer) { |
||
423 | |||
424 | // to add group layers to 3D, just add recursively child data layers
|
||
425 | if (layer instanceof FLayers) { |
||
426 | FLayers group = (FLayers) layer; |
||
427 | for (int iChild = 0; iChild < group.getLayersCount(); iChild++) { |
||
428 | layerAdded((FLayers3D) group, group.getLayer(iChild)); |
||
429 | } |
||
430 | getLayer3DProps(layer).setHooked(true);
|
||
431 | return;
|
||
432 | } |
||
433 | |||
434 | if (layer instanceof Classifiable) { |
||
435 | Classifiable legendLyr = (Classifiable) layer; |
||
436 | // legendLyr.addLegendListener((LegendListener) this);
|
||
437 | this.addLayerListener(this); |
||
438 | } |
||
439 | layer.addLayerListener((LayerListener) this);
|
||
440 | |||
441 | // listener to manage the selection for the layers
|
||
442 | if (layer.getClass().equals(FLyrVect.class)) {
|
||
443 | FLyrVect lyr = (FLyrVect) layer; |
||
444 | refreshLayerVectorsVisibility(lyr); |
||
445 | try {
|
||
446 | SelectableDataSource recordSet = lyr.getRecordset(); |
||
447 | if (recordSet != null) { |
||
448 | SelectionSupport selectionSupport = recordSet |
||
449 | 9 | jzarzoso | .getSelectionSupport(); |
450 | 5 | jzarzoso | selectionSupport.addSelectionListener(this);
|
451 | } |
||
452 | } catch (ReadDriverException e) {
|
||
453 | // TODO Auto-generated catch block
|
||
454 | e.printStackTrace(); |
||
455 | } |
||
456 | } |
||
457 | |||
458 | if (!_bLoading)
|
||
459 | addLayerToTerrain(layer, true);
|
||
460 | |||
461 | // Only do this the first time to add layer
|
||
462 | if (_bEmptyView && !_bLoading) {
|
||
463 | if (layers.getLayersCount() > 0) { |
||
464 | try {
|
||
465 | zoomToExtent(layer.getFullExtent()); |
||
466 | } catch (ExpansionFileReadException e) {
|
||
467 | e.printStackTrace(); |
||
468 | } catch (ReadDriverException e) {
|
||
469 | e.printStackTrace(); |
||
470 | } |
||
471 | _bEmptyView = false;
|
||
472 | } |
||
473 | } |
||
474 | |||
475 | 113 | mten | //PrintDebugLayers();
|
476 | 5 | jzarzoso | } |
477 | |||
478 | public void layerRemoved(FLayers3D parent, FLayer layer) { |
||
479 | |||
480 | // to remove group layers to 3D, just remove recursively child data
|
||
481 | // layers
|
||
482 | if (layer instanceof FLayers) { |
||
483 | FLayers group = (FLayers) layer; |
||
484 | for (int iChild = 0; iChild < group.getLayersCount(); iChild++) { |
||
485 | layerRemoved((FLayers3D) group, group.getLayer(iChild)); |
||
486 | } |
||
487 | getLayer3DProps(layer).setHooked(false);
|
||
488 | return;
|
||
489 | } |
||
490 | |||
491 | if (layer instanceof Classifiable) { |
||
492 | Classifiable legendLyr = (Classifiable) layer; |
||
493 | legendLyr.removeLegendListener((LegendListener) this);
|
||
494 | } |
||
495 | |||
496 | layer.removeLayerListener((LayerListener) this);
|
||
497 | |||
498 | removeLayerToTerrain(layer); |
||
499 | |||
500 | // All layers are removed
|
||
501 | if (layers.getLayersCount() == 0) { |
||
502 | _bEmptyView = true;
|
||
503 | } |
||
504 | |||
505 | PrintDebugLayers(); |
||
506 | } |
||
507 | |||
508 | /**
|
||
509 | * DOCUMENT ME!
|
||
510 | *
|
||
511 | * @param e
|
||
512 | * DOCUMENT ME!
|
||
513 | */
|
||
514 | public void legendChanged(LegendChangedEvent e) { |
||
515 | if (!_bListenToLegend)
|
||
516 | return;
|
||
517 | if ((e == null) && (!visibilityChange)) { |
||
518 | // find layer whose legend changed
|
||
519 | FLayer found = null;
|
||
520 | SingleLayerIterator lyrIterator = new SingleLayerIterator(layers);
|
||
521 | while (lyrIterator.hasNext()) {
|
||
522 | FLayer lyr = lyrIterator.next(); |
||
523 | if (lyr instanceof FLyrVect) { |
||
524 | FLyrVect lyrVect = (FLyrVect) lyr; |
||
525 | long newDrawVersion = lyrVect.getDrawVersion();
|
||
526 | Layer3DProps props3D = getLayer3DProps(lyrVect); |
||
527 | 90 | mten | if ((newDrawVersion - props3D.drawVersion) >= 1) { |
528 | 5 | jzarzoso | props3D.drawVersion = lyrVect.getDrawVersion(); |
529 | refreshLayerInTerrain(props3D, true);
|
||
530 | 40 | jzarzoso | refreshLayerVectorsVisibility(lyrVect); |
531 | 5 | jzarzoso | _bListenToLegend = false;
|
532 | 40 | jzarzoso | //props3D.VerifyLegend(_terrain.getTerrainName());
|
533 | 5 | jzarzoso | _bListenToLegend = true;
|
534 | 40 | jzarzoso | |
535 | 5 | jzarzoso | } |
536 | } |
||
537 | } |
||
538 | |||
539 | IWindow f = PluginServices.getMDIManager().getActiveWindow(); |
||
540 | if (f instanceof BaseView) { |
||
541 | BaseView view3D = (BaseView) f; |
||
542 | view3D.getTOC().refresh(); |
||
543 | } |
||
544 | } |
||
545 | visibilityChange = false;
|
||
546 | } |
||
547 | |||
548 | public void visibilityChanged(LayerEvent e) { |
||
549 | FLayer lyr = e.getSource(); |
||
550 | |||
551 | Layer3DProps props3D = getLayer3DProps(lyr); |
||
552 | |||
553 | if (props3D.getType() == Layer3DProps.layer3DVector) {
|
||
554 | refreshLayerVectorsVisibility(lyr); |
||
555 | } else if (props3D.getType() == Layer3DProps.layer3DOSG) { |
||
556 | refreshLayer3DOSGVisibility(lyr); |
||
557 | } else {
|
||
558 | refreshLayerVisibility(lyr); |
||
559 | } |
||
560 | visibilityChange = true;
|
||
561 | } |
||
562 | |||
563 | private void refreshLayer3DOSGVisibility(FLayer lyr) { |
||
564 | if (_terrain == null || _viewProjection == null) |
||
565 | return;
|
||
566 | |||
567 | Layer3DProps props3D = getLayer3DProps(lyr); |
||
568 | |||
569 | OSGCacheService cacheService = (OSGCacheService) props3D |
||
570 | 9 | jzarzoso | .getCacheService(); |
571 | 5 | jzarzoso | if (cacheService != null) { |
572 | // use VectorCacheService to add features to terrain
|
||
573 | cacheService.refreshFeaturesToTerrain(lyr.isVisible()); |
||
574 | } |
||
575 | |||
576 | } |
||
577 | |||
578 | private void refreshLayerVisibility(FLayer layer) { |
||
579 | |||
580 | Layer terrainLayer = _terrainFLayerMap.get(layer); |
||
581 | terrainLayer.setEnabled(layer.isVisible()); |
||
582 | _terrainLayerManager.updateLayers(); |
||
583 | |||
584 | } |
||
585 | |||
586 | private void refreshLayerVectorsVisibility(FLayer lyr) { |
||
587 | if (_terrain == null || _viewProjection == null) |
||
588 | return;
|
||
589 | |||
590 | Layer3DProps props3D = getLayer3DProps(lyr); |
||
591 | |||
592 | VectorCacheService cacheService = (VectorCacheService) props3D |
||
593 | 9 | jzarzoso | .getCacheService(); |
594 | 5 | jzarzoso | if (cacheService != null) { |
595 | // use VectorCacheService to add features to terrain
|
||
596 | cacheService.refreshFeaturesToTerrain(lyr.isVisible()); |
||
597 | props3D.drawVersion = lyr.getDrawVersion(); |
||
598 | } |
||
599 | |||
600 | } |
||
601 | |||
602 | public void activationChanged(LayerEvent e) { |
||
603 | 9 | jzarzoso | |
604 | 5 | jzarzoso | int a = 0; |
605 | } |
||
606 | |||
607 | public void nameChanged(LayerEvent e) { |
||
608 | // TODO Implement this method
|
||
609 | } |
||
610 | |||
611 | public void editionChanged(LayerEvent e) { |
||
612 | // TODO Implement this method
|
||
613 | |||
614 | } |
||
615 | |||
616 | public void refreshLayerInTerrain(Layer3DProps props, boolean bRemoveCache) { |
||
617 | if (props == null) |
||
618 | return;
|
||
619 | |||
620 | if (_terrain == null) |
||
621 | return; // view not opened yet |
||
622 | |||
623 | // clear cache
|
||
624 | |||
625 | 34 | mten | |
626 | 5 | jzarzoso | |
627 | // refresh layer in terrain
|
||
628 | int type = props.getType();
|
||
629 | if ((type == Layer3DProps.layer3DImage)
|
||
630 | || (type == Layer3DProps.layer3DElevation) |
||
631 | || (type == Layer3DProps.layer3DVectorMR)) { |
||
632 | 35 | jzarzoso | |
633 | if (bRemoveCache) {
|
||
634 | |||
635 | String layerCacheDir = Layer3DProps.m_cacheDir + File.separator |
||
636 | + _terrain.getTerrainName() + File.separator + props.getCacheName();
|
||
637 | |||
638 | FLayerCacheService cacheServices = (FLayerCacheService) props.getCacheService(); |
||
639 | if(cacheServices != null) |
||
640 | { |
||
641 | try {
|
||
642 | cacheServices.free(); |
||
643 | props.setCacheService(null);
|
||
644 | } catch (Throwable e) { |
||
645 | // TODO Auto-generated catch block
|
||
646 | e.printStackTrace(); |
||
647 | } |
||
648 | } |
||
649 | |||
650 | removeCache(new File(layerCacheDir)); |
||
651 | } |
||
652 | 5 | jzarzoso | try {
|
653 | _terrainLayerManager.invalidateLayer(props.getTerrainLayer()); |
||
654 | } catch (LayerManagementException e) {
|
||
655 | // TODO Auto-generated catch block
|
||
656 | e.printStackTrace(); |
||
657 | } |
||
658 | } else if (type == Layer3DProps.layer3DVector) { |
||
659 | invalidateVectorLayer(props); |
||
660 | } |
||
661 | } |
||
662 | |||
663 | private void invalidateVectorLayer(Layer3DProps props) { |
||
664 | // TODO Auto-generated method stub
|
||
665 | if (_terrain == null || _viewProjection == null) |
||
666 | return;
|
||
667 | |||
668 | VectorCacheService cacheService = (VectorCacheService) props |
||
669 | 9 | jzarzoso | .getCacheService(); |
670 | 5 | jzarzoso | if (cacheService != null) { |
671 | // use VectorCacheService to add features to terrain
|
||
672 | cacheService.refreshFeaturesToTerrain(); |
||
673 | } |
||
674 | } |
||
675 | |||
676 | 34 | mten | private boolean removeCache(File path) { |
677 | 35 | jzarzoso | if( path.exists() ) {
|
678 | File[] files = path.listFiles(); |
||
679 | for(int i=0; i<files.length; i++) { |
||
680 | if(files[i].isDirectory()) {
|
||
681 | removeCache(files[i]); |
||
682 | } |
||
683 | else {
|
||
684 | files[i].delete(); |
||
685 | } |
||
686 | } |
||
687 | } |
||
688 | return( path.delete() );
|
||
689 | 5 | jzarzoso | } |
690 | |||
691 | protected Layer3DProps getLayer3DProps(FLayer layer) {
|
||
692 | |||
693 | Layer3DProps props3D = Layer3DProps.getLayer3DProps(layer); |
||
694 | |||
695 | // Create instance of props for osg layers.
|
||
696 | if (props3D == null) { |
||
697 | props3D = new Layer3DProps();
|
||
698 | if (layer instanceof FLyrVect) { |
||
699 | FLyrVect nLayer = (FLyrVect) layer; |
||
700 | Driver driver;
|
||
701 | try {
|
||
702 | driver = nLayer.getRecordset().getDriver(); |
||
703 | if (driver instanceof GvsigDriverOSG) { |
||
704 | props3D.setChooseType(false);
|
||
705 | props3D.setType(Layer3DProps.layer3DOSG); |
||
706 | } |
||
707 | } catch (ReadDriverException e) {
|
||
708 | // TODO Auto-generated catch block
|
||
709 | e.printStackTrace(); |
||
710 | } |
||
711 | |||
712 | } |
||
713 | // Set the properties
|
||
714 | props3D.setLayer(layer); |
||
715 | |||
716 | props3D.initCacheName(_terrain.getCoordinateSystemType(), |
||
717 | _viewProjection, Terrain.CoordinateSystemType.GEOCENTRIC); |
||
718 | FLyrDefault baseLayer = (FLyrDefault) layer; |
||
719 | baseLayer.setProperty("3DLayerExtension", props3D);
|
||
720 | props3D.setVerticalEx(getVerticalExaggeration()); |
||
721 | } else {
|
||
722 | if (_bLoading)
|
||
723 | props3D.setChooseType(false);
|
||
724 | props3D.setLayer(layer); |
||
725 | } |
||
726 | |||
727 | return props3D;
|
||
728 | } |
||
729 | |||
730 | public void addCurrentLayers() { |
||
731 | SingleLayerIterator lyrIterator = new SingleLayerIterator(layers);
|
||
732 | while (lyrIterator.hasNext()) {
|
||
733 | FLayer layer = lyrIterator.next(); |
||
734 | Layer3DProps props = getLayer3DProps(layer); |
||
735 | // props.setTerrainOrder(props.getTocOrder());
|
||
736 | addLayerToTerrain(layer, false);
|
||
737 | } |
||
738 | } |
||
739 | |||
740 | public void addLayerToTerrain(FLayer layer, |
||
741 | boolean bVerifyLegend) {
|
||
742 | Layer3DProps props3D = getLayer3DProps(layer); |
||
743 | |||
744 | if (props3D.getType() == Layer3DProps.layer3DVector) {
|
||
745 | CreateVectors(layer, props3D); // special case for now without
|
||
746 | // disk cache
|
||
747 | } else if (props3D.getType() == Layer3DProps.layer3DOSG) { |
||
748 | CreateOSGLayer(layer, props3D); |
||
749 | } else {
|
||
750 | Rectangle2D layerExtent = null; |
||
751 | try {
|
||
752 | layerExtent = layer.getFullExtent(); |
||
753 | } catch (ExpansionFileReadException e) {
|
||
754 | e.printStackTrace(); |
||
755 | } catch (ReadDriverException e) {
|
||
756 | e.printStackTrace(); |
||
757 | } |
||
758 | if (layerExtent == null) { // hack for missing extents |
||
759 | if (_terrain.getCoordinateSystemType() == Terrain.CoordinateSystemType.GEOCENTRIC)
|
||
760 | layerExtent = new Rectangle2D.Double(-180.0, -90.0, 360.0, |
||
761 | 180.0);
|
||
762 | else
|
||
763 | layerExtent = new Rectangle2D.Double(-20000000.0, |
||
764 | -10000000.0, 40000000.0, 20000000.0); |
||
765 | // TODO toggle comment because this code use WCS extension. When
|
||
766 | // WCS extension runs correctly uncoment!!!
|
||
767 | |||
768 | if (layer instanceof FLyrWCS) |
||
769 | ((FLyrWCS) layer).setFullExtent(layerExtent); |
||
770 | } |
||
771 | |||
772 | Extent extent = null;
|
||
773 | if (_terrain.getCoordinateSystemType() == CoordinateSystemType.PROJECTED) {
|
||
774 | extent = new Extent(layerExtent.getMinX(), layerExtent
|
||
775 | .getMinY(), layerExtent.getMaxX(), layerExtent |
||
776 | .getMaxY()); |
||
777 | } else {
|
||
778 | extent = new Extent(Math.toRadians(layerExtent.getMinX()), Math |
||
779 | .toRadians(layerExtent.getMinY()), Math
|
||
780 | .toRadians(layerExtent.getMaxX()), Math
|
||
781 | .toRadians(layerExtent.getMaxY())); |
||
782 | } |
||
783 | |||
784 | if (props3D.getType() == Layer3DProps.layer3DImage) {
|
||
785 | RasterLayer rlayer = new RasterLayer();
|
||
786 | rlayer.setEnabled(layer.isVisible()); |
||
787 | rlayer.setExtent(extent); |
||
788 | rlayer.setOpacity(props3D.getOpacity()); |
||
789 | rlayer.setDataDriver(_terrainDataManager); |
||
790 | 97 | rgaitan | _logger.warn("computed optimum level = "+computeOptimumLevel(layer,20,256)); |
791 | rlayer.setMaxResolution(computeOptimumLevel(layer,20,256)); |
||
792 | 5 | jzarzoso | try {
|
793 | _terrainLayerManager.addLayer(rlayer); |
||
794 | } catch (LayerManagementException e) {
|
||
795 | // TODO Auto-generated catch block
|
||
796 | e.printStackTrace(); |
||
797 | } |
||
798 | _terrainFLayerMap.put(layer, rlayer); |
||
799 | _terrainLayerMap.put(rlayer.getLayerID(), layer); |
||
800 | props3D.setTerrainLayer(rlayer); |
||
801 | 92 | mten | // Refresh cache for vector rasterized layers
|
802 | if (layer.getClass().equals(FLyrVect.class)) {
|
||
803 | refreshLayerInTerrain(props3D, true);
|
||
804 | } |
||
805 | 5 | jzarzoso | } else if (props3D.getType() == Layer3DProps.layer3DElevation) { |
806 | HeightfieldLayer hlayer = new HeightfieldLayer();
|
||
807 | hlayer.setEnabled(layer.isVisible()); |
||
808 | hlayer.setExtent(extent); |
||
809 | hlayer.setVerticalExaggeration(props3D.getVerticalEx()); |
||
810 | 97 | rgaitan | _logger.warn("computed optimum level = "+computeOptimumLevel(layer,20,32)); |
811 | hlayer.setMaxResolution(computeOptimumLevel(layer,20,32)); |
||
812 | 5 | jzarzoso | hlayer.setDataDriver(_terrainDataManager); |
813 | try {
|
||
814 | _terrainLayerManager.addLayer(hlayer); |
||
815 | } catch (LayerManagementException e) {
|
||
816 | // TODO Auto-generated catch block
|
||
817 | e.printStackTrace(); |
||
818 | } |
||
819 | _terrainFLayerMap.put(layer, hlayer); |
||
820 | _terrainLayerMap.put(hlayer.getLayerID(), layer); |
||
821 | props3D.setTerrainLayer(hlayer); |
||
822 | } else if (props3D.getType() == Layer3DProps.layer3DVectorMR) { |
||
823 | VectorLayer vlayer = new VectorLayer();
|
||
824 | vlayer.setEnabled(true);
|
||
825 | vlayer.setExtent(extent); |
||
826 | vlayer.setDensity(1.0f);
|
||
827 | vlayer.setDataDriver(_terrainDataManager); |
||
828 | try {
|
||
829 | _terrainLayerManager.addLayer(vlayer); |
||
830 | } catch (LayerManagementException e) {
|
||
831 | // TODO Auto-generated catch block
|
||
832 | e.printStackTrace(); |
||
833 | } |
||
834 | _terrainFLayerMap.put(layer, vlayer); |
||
835 | _terrainLayerMap.put(vlayer.getLayerID(), layer); |
||
836 | props3D.setTerrainLayer(vlayer); |
||
837 | } |
||
838 | |||
839 | if (bVerifyLegend) {
|
||
840 | _bListenToLegend = false;
|
||
841 | props3D.VerifyLegend(_terrain.getTerrainName()); |
||
842 | _bListenToLegend = true;
|
||
843 | } |
||
844 | } |
||
845 | } |
||
846 | |||
847 | 97 | rgaitan | public int computeOptimumLevel(FLayer layer, int maxLevel, double tileSize) { |
848 | 91 | rgaitan | int level = maxLevel;
|
849 | if(!(layer instanceof FLyrRasterSE)) |
||
850 | return level;
|
||
851 | |||
852 | |||
853 | Rectangle2D ext = null; |
||
854 | try {
|
||
855 | ext = layer.getFullExtent(); |
||
856 | } catch (ReadDriverException e1) {
|
||
857 | NotificationManager.addError("Error al obtener el extent", e1);
|
||
858 | } |
||
859 | |||
860 | ArrayList attr = ((FLyrRasterSE)layer).getAttributes();
|
||
861 | int width = 0, height = 0; |
||
862 | for (int i=0; i<attr.size(); i++) { |
||
863 | Object[] a = (Object []) attr.get(i); |
||
864 | if (a[0].toString().equals("Width")) |
||
865 | width = ((Integer)a[1]).intValue(); |
||
866 | if (a[0].toString().equals("Height")) |
||
867 | height = ((Integer)a[1]).intValue(); |
||
868 | } |
||
869 | |||
870 | if( ext != null && |
||
871 | width != 0 &&
|
||
872 | height != 0){
|
||
873 | |||
874 | Extent destinationExtents = _terrain.getExtent(); |
||
875 | 97 | rgaitan | double xMax = destinationExtents.xMax();
|
876 | double xMin = destinationExtents.xMin();
|
||
877 | double yMax = destinationExtents.yMax();
|
||
878 | double yMin = destinationExtents.yMin();
|
||
879 | int terrainType = _terrain.getCoordinateSystemType();
|
||
880 | if(terrainType == Terrain.CoordinateSystemType.GEOCENTRIC)
|
||
881 | { |
||
882 | xMax = Math.toDegrees(xMax);
|
||
883 | xMin = Math.toDegrees(xMin);
|
||
884 | yMax = Math.toDegrees(yMax);
|
||
885 | yMin = Math.toDegrees(yMin);
|
||
886 | } |
||
887 | |||
888 | double destination_xRange = xMax-xMin;
|
||
889 | double destination_yRange = yMax-yMin;
|
||
890 | 91 | rgaitan | double AR = destination_xRange / destination_yRange;
|
891 | int C1 = 1; |
||
892 | int R1 = 1; |
||
893 | |||
894 | boolean swapAxis = AR<1.0; |
||
895 | if (swapAxis) AR = 1.0/AR; |
||
896 | |||
897 | double lower_AR = Math.floor(AR); |
||
898 | double upper_AR = Math.ceil(AR); |
||
899 | |||
900 | if (AR<Math.sqrt(lower_AR*upper_AR)) |
||
901 | { |
||
902 | C1 = (int)(lower_AR);
|
||
903 | R1 = 1;
|
||
904 | } |
||
905 | else
|
||
906 | { |
||
907 | C1 = (int)(upper_AR);
|
||
908 | R1 = 1;
|
||
909 | } |
||
910 | |||
911 | if (swapAxis)
|
||
912 | { |
||
913 | //std::swap(C1,R1);
|
||
914 | int t = C1;
|
||
915 | C1 = R1; |
||
916 | R1 = t; |
||
917 | } |
||
918 | |||
919 | |||
920 | double source_xRange = ext.getMaxX() - ext.getMinX();
|
||
921 | double source_yRange = ext.getMaxY() - ext.getMinY();
|
||
922 | |||
923 | float sourceResolutionX = ((float)source_xRange)/(float)width; |
||
924 | float sourceResolutionY = ((float)source_yRange)/(float)height; |
||
925 | |||
926 | // log(osg::NOTICE,"Source %s resX %f resY %f",source->getFileName().c_str(), sourceResolutionX, sourceResolutionX);
|
||
927 | |||
928 | |||
929 | int k_cols = (int)( Math.ceil( 1.0 + Math.log( destination_xRange / (C1 * sourceResolutionX * tileSize ) ) / Math.log(2.0) ) ); |
||
930 | int k_rows = (int)( Math.ceil( 1.0 + Math.log( destination_yRange / (R1 * sourceResolutionY * tileSize ) ) / Math.log(2.0) ) ); |
||
931 | level = Math.max(k_cols, k_rows);
|
||
932 | level = Math.min(level, maxLevel);
|
||
933 | level = Math.max(level, 0); |
||
934 | } |
||
935 | return level;
|
||
936 | } |
||
937 | |||
938 | 5 | jzarzoso | private void CreateOSGLayer(FLayer layer, Layer3DProps props3D) { |
939 | if (_terrain == null || _viewProjection == null) |
||
940 | return;
|
||
941 | |||
942 | OSGCacheService cacheService = (OSGCacheService) props3D |
||
943 | 9 | jzarzoso | .getCacheService(); |
944 | 5 | jzarzoso | if (cacheService == null) { |
945 | cacheService = new OSGCacheService(_canvas3d, _terrain, props3D
|
||
946 | .getCacheName(), layer, _viewProjection); |
||
947 | cacheService.setCacheRootDir(Layer3DProps.m_cacheDir); |
||
948 | props3D.setCacheService(cacheService); |
||
949 | } |
||
950 | |||
951 | // use VectorCacheService to add features to planet
|
||
952 | cacheService.AddFeaturesToTerrain(); |
||
953 | |||
954 | } |
||
955 | |||
956 | @Override
|
||
957 | public XMLEntity getXMLEntity() throws XMLException { |
||
958 | // TODO Auto-generated method stub
|
||
959 | XMLEntity xml = super.getXMLEntity();
|
||
960 | |||
961 | SingleLayerIterator lyrIterator = new SingleLayerIterator(layers);
|
||
962 | while (lyrIterator.hasNext()) {
|
||
963 | FLayer lyr = lyrIterator.next(); |
||
964 | Layer3DProps props3D = getLayer3DProps(lyr); |
||
965 | int type = props3D.getType();
|
||
966 | if (type == Layer3DProps.layer3DOSG) {
|
||
967 | |||
968 | OSGCacheService cacheService = (OSGCacheService) props3D |
||
969 | 9 | jzarzoso | .getCacheService(); |
970 | 5 | jzarzoso | if (cacheService != null) { |
971 | // use VectorCacheService to add features to planet
|
||
972 | if (props3D.isEditing()) {
|
||
973 | // TODO: PONER AKI EL CODIGO DE SALVAR
|
||
974 | } |
||
975 | } |
||
976 | } |
||
977 | } |
||
978 | |||
979 | return xml;
|
||
980 | |||
981 | } |
||
982 | |||
983 | private void CreateVectors(FLayer layer, Layer3DProps props3D) { |
||
984 | if (_terrain == null || _viewProjection == null) |
||
985 | return;
|
||
986 | |||
987 | VectorCacheService cacheService = (VectorCacheService) props3D |
||
988 | 9 | jzarzoso | .getCacheService(); |
989 | 5 | jzarzoso | if (cacheService == null) { |
990 | cacheService = new VectorCacheService(_canvas3d, _terrain, props3D
|
||
991 | .getCacheName(), layer, _viewProjection); |
||
992 | cacheService.setCacheRootDir(Layer3DProps.m_cacheDir); |
||
993 | props3D.setCacheService(cacheService); |
||
994 | } |
||
995 | |||
996 | // use VectorCacheService to add features to terrain
|
||
997 | cacheService.addFeaturesToTerrain(); |
||
998 | } |
||
999 | |||
1000 | private void DeleteVectors(FLayer layer, Layer3DProps props3D) { |
||
1001 | if (_terrain == null || _viewProjection == null) |
||
1002 | return;
|
||
1003 | |||
1004 | VectorCacheService cacheService = (VectorCacheService) props3D |
||
1005 | 9 | jzarzoso | .getCacheService(); |
1006 | 5 | jzarzoso | if (cacheService != null) { |
1007 | // use VectorCacheService to delete features to terrain
|
||
1008 | cacheService.deleteFeaturesToTerrain(); |
||
1009 | } |
||
1010 | } |
||
1011 | |||
1012 | /**
|
||
1013 | * Sets the given zoom extent to the view
|
||
1014 | *
|
||
1015 | * @param extent
|
||
1016 | * The extent to zoom to.
|
||
1017 | */
|
||
1018 | public void zoomToExtent(Rectangle2D geoExtent) { |
||
1019 | 113 | mten | |
1020 | if(geoExtent == null) return; |
||
1021 | |||
1022 | 5 | jzarzoso | double maxHeight = 0.0; |
1023 | |||
1024 | // Getting extent positions
|
||
1025 | double minLat = geoExtent.getMinY();
|
||
1026 | double maxLat = geoExtent.getMaxY();
|
||
1027 | double cenLon = geoExtent.getCenterX();
|
||
1028 | double cenLat = geoExtent.getCenterY();
|
||
1029 | |||
1030 | double elevation = 0; |
||
1031 | |||
1032 | // calculate altitude
|
||
1033 | double avLat = 0; |
||
1034 | if (minLat > 0.0 || maxLat < 0.0) |
||
1035 | avLat = Math.min(Math.abs(minLat), Math.abs(maxLat)); |
||
1036 | double avLon = Math.min(180.0, geoExtent.getWidth()); |
||
1037 | |||
1038 | double terrainRadius = _terrain.getRadiusEquatorial();
|
||
1039 | double radiusLat = terrainRadius * Math.cos(Math.toRadians(avLat)); |
||
1040 | double deltaLon = Math.sqrt(2 * radiusLat * radiusLat |
||
1041 | * (1 - Math.cos(Math.toRadians(avLon)))); |
||
1042 | double deltaLat = Math.sqrt(2 * terrainRadius * terrainRadius |
||
1043 | * (1 - Math.cos(Math.toRadians(geoExtent.getHeight())))); |
||
1044 | |||
1045 | double zoomFactor = 1.5; |
||
1046 | elevation = (Math.max(deltaLon, deltaLat) * zoomFactor) + maxHeight;
|
||
1047 | |||
1048 | // Calculate XYZ positions for camera.
|
||
1049 | |||
1050 | int terrainType = _terrain.getCoordinateSystemType();
|
||
1051 | |||
1052 | Vec3 eye = new Vec3();
|
||
1053 | Vec3 center = new Vec3();
|
||
1054 | Vec3 up = new Vec3();
|
||
1055 | // Calculate positions for PLAIN MODE.
|
||
1056 | if (terrainType == Terrain.CoordinateSystemType.PROJECTED) {
|
||
1057 | |||
1058 | double difx = (geoExtent.getMaxX() - geoExtent.getX()) / 1.2d; |
||
1059 | double dify = (geoExtent.getMaxY() - geoExtent.getY()) / 1.2d; |
||
1060 | double height;
|
||
1061 | |||
1062 | height = Math.sqrt(difx * difx + dify * dify);
|
||
1063 | double fullWindowFactor = 1.7; |
||
1064 | // EYE
|
||
1065 | eye.setX(cenLon); |
||
1066 | eye.setY(cenLat); |
||
1067 | eye.setZ(height * fullWindowFactor); |
||
1068 | // CENTER
|
||
1069 | center.setX(cenLon); |
||
1070 | center.setY(cenLat); |
||
1071 | center.setZ(0.0);
|
||
1072 | // UP
|
||
1073 | up.setX(0.0);
|
||
1074 | up.setY(1.0);
|
||
1075 | up.setZ(0.0);
|
||
1076 | } else
|
||
1077 | 9 | jzarzoso | // Calculate positions for SPHERICAL MODE.
|
1078 | if (terrainType == Terrain.CoordinateSystemType.GEOCENTRIC) {
|
||
1079 | // EYE
|
||
1080 | Vec3 aux = new Vec3(cenLat, cenLon, elevation);
|
||
1081 | eye = _terrain.convertLatLongHeightToXYZ(aux); |
||
1082 | // CENTER
|
||
1083 | center.setX(0.0);
|
||
1084 | center.setY(0.0);
|
||
1085 | center.setZ(0.0);
|
||
1086 | // UP
|
||
1087 | up.setX(0.0);
|
||
1088 | up.setY(0.0);
|
||
1089 | up.setZ(1.0);
|
||
1090 | } |
||
1091 | 5 | jzarzoso | Camera cam = new Camera();
|
1092 | cam.setViewByLookAt(eye, center, up); |
||
1093 | |||
1094 | _terrainViewer.setCamera(cam); |
||
1095 | |||
1096 | } |
||
1097 | |||
1098 | private void PrintDebugLayers() { |
||
1099 | if (_terrainLayerManager != null) { |
||
1100 | System.out.println("==========================="); |
||
1101 | System.out.println("Total terrain layers: " |
||
1102 | + _terrainLayerManager.getNumLayers()); |
||
1103 | System.out.println("==========================="); |
||
1104 | } |
||
1105 | SingleLayerIterator lyrIterator = new SingleLayerIterator(layers);
|
||
1106 | int pos = 0; |
||
1107 | while (lyrIterator.hasNext()) {
|
||
1108 | FLayer layer = lyrIterator.next(); |
||
1109 | System.out.println(" Layer " + layer.getName()); |
||
1110 | Layer3DProps props3D = getLayer3DProps(layer); |
||
1111 | System.out.println(" Type " + props3D.getType()); |
||
1112 | System.out.println(" Order " + pos); |
||
1113 | pos++; |
||
1114 | } |
||
1115 | } |
||
1116 | |||
1117 | /**
|
||
1118 | * Crea un nuevo MapContext(3D) a partir del XMLEntity.
|
||
1119 | *
|
||
1120 | * @param xml
|
||
1121 | * XMLEntity
|
||
1122 | *
|
||
1123 | * @return Nuevo MapContext3D.
|
||
1124 | *
|
||
1125 | * @throws XMLException
|
||
1126 | */
|
||
1127 | public static MapContext createFromXML(XMLEntity xml) throws XMLException { |
||
1128 | ViewPort3D vp = (ViewPort3D) ViewPort3D.createFromXML(xml.getChild(0));
|
||
1129 | |||
1130 | FLayers layers = new FLayers3D(null, null, vp); |
||
1131 | layers.setXMLEntity(xml.getChild(1));
|
||
1132 | |||
1133 | MapContext fmap = layers.getMapContext(); |
||
1134 | |||
1135 | return fmap;
|
||
1136 | } |
||
1137 | |||
1138 | public static MapContext createFromXML03(XMLEntity xml) throws XMLException { |
||
1139 | ViewPort vp = ViewPort.createFromXML03(xml.getChild(0));
|
||
1140 | |||
1141 | FLayers layers = new FLayers3D(null, null, vp); |
||
1142 | layers.setXMLEntity03(xml.getChild(1));
|
||
1143 | |||
1144 | MapContext fmap = layers.getMapContext(); |
||
1145 | |||
1146 | return fmap;
|
||
1147 | } |
||
1148 | |||
1149 | public GraphicLayer getGraphicsLayer() {
|
||
1150 | GraphicLayer3D gra3D = new GraphicLayer3D(_terrainViewer, getTerrain());
|
||
1151 | return gra3D;
|
||
1152 | } |
||
1153 | |||
1154 | public Node getSpecialNode() {
|
||
1155 | Node specialNode = null;
|
||
1156 | try {
|
||
1157 | specialNode = _terrainViewer.getFeature(0);
|
||
1158 | } catch (ChildIndexOutOfBoundsExceptions e) {
|
||
1159 | _logger.error("Command: " + "Error child index out of bound.", e); |
||
1160 | } |
||
1161 | return specialNode;
|
||
1162 | } |
||
1163 | |||
1164 | public ViewPort getViewPort() {
|
||
1165 | |||
1166 | ViewPort3D vp = (ViewPort3D) super.getViewPort();
|
||
1167 | |||
1168 | if (_canvas3d != null) |
||
1169 | vp.setImageSize(new Dimension(_terrainViewer.getWidth(), |
||
1170 | _terrainViewer.getHeight())); |
||
1171 | vp.setTerrain(this.getTerrain());
|
||
1172 | vp.setViewer(this._canvas3d);
|
||
1173 | |||
1174 | return vp;
|
||
1175 | } |
||
1176 | |||
1177 | /**
|
||
1178 | * M๏ฟฝtodo de conveniencia que se usa provisionalmente para solicitar un
|
||
1179 | * refresco de todo lo que dependa del FMap (MapContext). Esto provocar๏ฟฝ un
|
||
1180 | * evento de cambio de orden de capas que obligar๏ฟฝ a redibujar todo lo que
|
||
1181 | * depende de FMap (TOC, MapControl, FFrameView, etc).
|
||
1182 | */
|
||
1183 | |||
1184 | /*
|
||
1185 | * public void invalidate() { ViewPort3D vp = (ViewPort3D)
|
||
1186 | * super.getViewPort(); if (vp.getDirty()) { vp.setDirty(false); } FLayer[]
|
||
1187 | * selectedExtent = getLayers().getActives();
|
||
1188 | *
|
||
1189 | * if (selectedExtent.length > 0) { for (int i = 0; i <
|
||
1190 | * selectedExtent.length; i++) { if (selectedExtent[0].isAvailable()) {
|
||
1191 | *
|
||
1192 | * FLayer lyr3D = selectedExtent[i]; Layer3DProps layer3DProps =
|
||
1193 | * Layer3DProps .getLayer3DProps(lyr3D);
|
||
1194 | *
|
||
1195 | * Layer terrainLayer = _terrainFLayerMap.get(lyr3D); float opacity =
|
||
1196 | * (((FLyrDefault) lyr3D).getTransparency()) / (float) 255; if()
|
||
1197 | * //_terrain.setTextureOpacityLayer(order, opacity); } }
|
||
1198 | *
|
||
1199 | * } }
|
||
1200 | */
|
||
1201 | |||
1202 | public void selectionChanged(SelectionEvent e) { |
||
1203 | // TODO Auto-generated method stub
|
||
1204 | SingleLayerIterator lyrIterator = new SingleLayerIterator(layers);
|
||
1205 | while (lyrIterator.hasNext()) {
|
||
1206 | FLayer layer = lyrIterator.next(); |
||
1207 | Layer3DProps props3D = getLayer3DProps(layer); |
||
1208 | if (props3D.getType() != Layer3DProps.layer3DOSG) {
|
||
1209 | if (layer.getClass().equals(FLyrVect.class)) {
|
||
1210 | FLyrVect lyr = (FLyrVect) layer; |
||
1211 | |||
1212 | FBitSet selection = null;
|
||
1213 | try {
|
||
1214 | selection = lyr.getRecordset().getSelectionSupport() |
||
1215 | 9 | jzarzoso | .getSelection(); |
1216 | 5 | jzarzoso | } catch (ReadDriverException e1) {
|
1217 | // TODO Auto-generated catch block
|
||
1218 | e1.printStackTrace(); |
||
1219 | } |
||
1220 | |||
1221 | if ((selection.cardinality() == 0) |
||
1222 | || (!(selection.isEmpty()))) { |
||
1223 | Layer3DProps props = Layer3DProps |
||
1224 | 9 | jzarzoso | .getLayer3DProps(layer); |
1225 | 5 | jzarzoso | refreshLayerInTerrain(props, true);
|
1226 | if (layer instanceof FLyrVect) { |
||
1227 | FLyrVect fvect = (FLyrVect) layer; |
||
1228 | props.drawVersion = fvect.getDrawVersion(); |
||
1229 | } |
||
1230 | } |
||
1231 | } |
||
1232 | } |
||
1233 | } |
||
1234 | } |
||
1235 | |||
1236 | public void removeLayerToTerrain(FLayer layer) { |
||
1237 | // TODO Auto-generated method stub
|
||
1238 | Layer3DProps props3D = getLayer3DProps(layer); |
||
1239 | |||
1240 | if (props3D.getType() == Layer3DProps.layer3DVector) {
|
||
1241 | DeleteVectors(layer, props3D); |
||
1242 | } else if (props3D.getType() == Layer3DProps.layer3DOSG) { |
||
1243 | DeleteOSGLayer(layer, props3D); |
||
1244 | } else {
|
||
1245 | Layer terrainLayer = _terrainFLayerMap.get(layer); |
||
1246 | if (terrainLayer != null) { |
||
1247 | FLayerCacheService cacheService = (FLayerCacheService) props3D.getCacheService(); |
||
1248 | if(cacheService != null) |
||
1249 | try {
|
||
1250 | cacheService.free(); |
||
1251 | } catch (Throwable e) { |
||
1252 | // TODO Auto-generated catch block
|
||
1253 | e.printStackTrace(); |
||
1254 | } |
||
1255 | 9 | jzarzoso | _terrainLayerMap.remove(terrainLayer.getLayerID()); |
1256 | _terrainFLayerMap.remove(layer); |
||
1257 | 5 | jzarzoso | |
1258 | 9 | jzarzoso | try {
|
1259 | _terrainLayerManager.removeLayer(terrainLayer); |
||
1260 | } catch (LayerManagementException e) {
|
||
1261 | // TODO Auto-generated catch block
|
||
1262 | e.printStackTrace(); |
||
1263 | } |
||
1264 | 5 | jzarzoso | } |
1265 | } |
||
1266 | |||
1267 | } |
||
1268 | |||
1269 | private void DeleteOSGLayer(FLayer layer, Layer3DProps props3D) { |
||
1270 | if (_terrain == null || _viewProjection == null) |
||
1271 | return;
|
||
1272 | |||
1273 | OSGCacheService cacheService = (OSGCacheService) props3D |
||
1274 | 9 | jzarzoso | .getCacheService(); |
1275 | 5 | jzarzoso | if (cacheService != null) { |
1276 | // use VectorCacheService to delete features to terrain
|
||
1277 | cacheService.DeleteFeaturesToTerrain(); |
||
1278 | } |
||
1279 | } |
||
1280 | |||
1281 | public boolean isRenewCanvasOff() { |
||
1282 | return _renewCanvasOff;
|
||
1283 | } |
||
1284 | |||
1285 | public void setRenewCanvasOff(boolean renewCanvasOff) { |
||
1286 | _renewCanvasOff = renewCanvasOff; |
||
1287 | } |
||
1288 | |||
1289 | public void drawValueChanged(LayerEvent arg0) { |
||
1290 | // TODO Auto-generated method stub
|
||
1291 | |||
1292 | } |
||
1293 | |||
1294 | 9 | jzarzoso | |
1295 | |||
1296 | 5 | jzarzoso | public UpdateDataEvent loadData(RequestDataEvent rde) {
|
1297 | |||
1298 | if (_terrainLayerMap.size() == 0) |
||
1299 | return null; |
||
1300 | if (rde == null) |
||
1301 | return null; |
||
1302 | if (rde.getExtent() == null) |
||
1303 | return null; |
||
1304 | if (rde.getLayer() == null) |
||
1305 | return null; |
||
1306 | if (rde.getLayerManager() == null) |
||
1307 | return null; |
||
1308 | |||
1309 | UpdateDataEvent ude = new UpdateDataEvent();
|
||
1310 | ude.copyDataFromRequest(rde); |
||
1311 | |||
1312 | 9 | jzarzoso | |
1313 | 5 | jzarzoso | String layerID = rde.getLayer().getLayerID();
|
1314 | FLayer layer = (FLayer) _terrainLayerMap.get(layerID); |
||
1315 | if (layer == null) |
||
1316 | return null; |
||
1317 | if (!layer.isVisible())
|
||
1318 | return null; |
||
1319 | |||
1320 | Layer3DProps props3D = getLayer3DProps(layer); |
||
1321 | |||
1322 | // get/create cache service
|
||
1323 | FLayerCacheService cacheService = (FLayerCacheService) props3D |
||
1324 | 9 | jzarzoso | .getCacheService(); |
1325 | 5 | jzarzoso | if (cacheService == null) { |
1326 | 35 | jzarzoso | |
1327 | 5 | jzarzoso | cacheService = new FLayerCacheService(_terrain, props3D
|
1328 | .getCacheName(), layer, _viewProjection); |
||
1329 | cacheService.setCacheRootDir(Layer3DProps.m_cacheDir); |
||
1330 | props3D.setCacheService(cacheService); |
||
1331 | 9 | jzarzoso | |
1332 | 5 | jzarzoso | } |
1333 | |||
1334 | 9 | jzarzoso | |
1335 | |||
1336 | 5 | jzarzoso | int dataType = props3D.getType();
|
1337 | Point tileIndices = new Point(rde.getTileX(), rde.getTileY()); |
||
1338 | TileNum tileNum = new TileNum(rde.getTileLevel(), tileIndices);
|
||
1339 | |||
1340 | String tileFileName = ""; |
||
1341 | |||
1342 | double minX, minY, width, height;
|
||
1343 | |||
1344 | if (_terrain.getCoordinateSystemType() == CoordinateSystemType.PROJECTED) {
|
||
1345 | minX = rde.getExtent().xMin(); |
||
1346 | minY = rde.getExtent().yMin(); |
||
1347 | width = rde.getExtent().xMax() - rde.getExtent().xMin(); |
||
1348 | height = rde.getExtent().yMax() - rde.getExtent().yMin(); |
||
1349 | } else {
|
||
1350 | minX = Math.toDegrees(rde.getExtent().xMin());
|
||
1351 | minY = Math.toDegrees(rde.getExtent().yMin());
|
||
1352 | width = Math.toDegrees(rde.getExtent().xMax()
|
||
1353 | - rde.getExtent().xMin()); |
||
1354 | height = Math.toDegrees(rde.getExtent().yMax()
|
||
1355 | - rde.getExtent().yMin()); |
||
1356 | } |
||
1357 | boolean failData = false; |
||
1358 | |||
1359 | Rectangle2D extent = new Rectangle2D.Double(minX, minY, width, height); |
||
1360 | if (cacheService.intersectsLayer(extent)) { // extent test |
||
1361 | try {
|
||
1362 | tileFileName = cacheService.getTileAsFName(tileNum, extent); |
||
1363 | if (tileFileName == null) |
||
1364 | failData = true;
|
||
1365 | } catch (Exception e) { |
||
1366 | failData = true;
|
||
1367 | NotificationManager.addInfo("Problem reading tile:" + tileNum,
|
||
1368 | e); |
||
1369 | e.printStackTrace(); |
||
1370 | } |
||
1371 | |||
1372 | if (failData) {
|
||
1373 | return null; |
||
1374 | // ude.setFailData();
|
||
1375 | } else {
|
||
1376 | switch (dataType) {
|
||
1377 | case Layer3DProps.layer3DImage:
|
||
1378 | ude.setRasterData(tileFileName, "gdal");
|
||
1379 | break;
|
||
1380 | case Layer3DProps.layer3DElevation:
|
||
1381 | ude.setHeightfieldData(tileFileName, "gdal");
|
||
1382 | break;
|
||
1383 | case Layer3DProps.layer3DVectorMR:
|
||
1384 | ude.setVectorData(tileFileName, "osg");
|
||
1385 | break;
|
||
1386 | } |
||
1387 | } |
||
1388 | } |
||
1389 | |||
1390 | return ude;
|
||
1391 | } |
||
1392 | } |