org.argeo.dep.osgi.jai.imageio;bundle-version="1.1.0"
Bundle-ActivationPolicy: lazy
Bundle-RequiredExecutionEnvironment: J2SE-1.5
-Import-Package: org.argeo.eclipse.spring,
+Import-Package: com.vividsolutions.jts.geom;version="1.10.0",
+ org.apache.commons.logging;version="1.1.1",
+ org.argeo.eclipse.spring,
+ org.argeo.slc.geotools;version="0.13.0.SNAPSHOT-r3817",
+ org.argeo.slc.geotools.data,
org.argeo.slc.geotools.swing;version="0.13.0.SNAPSHOT-r3817",
+ org.argeo.slc.gis.model;version="0.13.0.SNAPSHOT-r3817",
org.argeo.slc.jts;version="0.13.0.SNAPSHOT-r3817",
org.geotools.data,
+ org.geotools.gce.image,
+ org.geotools.geometry,
+ org.geotools.map,
+ org.geotools.renderer,
+ org.geotools.renderer.lite,
+ org.geotools.styling,
+ org.geotools.swing,
+ org.geotools.swing.event,
+ org.geotools.swing.tool,
+ org.opengis.feature.simple,
+ org.opengis.geometry,
+ org.opengis.referencing.crs,
org.springframework.osgi.util;version="1.2.1"
http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">\r
\r
<reference id="positionProvider" interface="org.argeo.slc.jts.PositionProvider" />\r
- \r
- <reference id="postGisDataStore" interface="org.geotools.data.DataStore" />\r
- <!--\r
-<service ref="postGisDataStore" interface="org.geotools.data.DataStore" />\r
- <bundle id="geotools" symbolic-name="org.argeo.dep.osgi.geotools" />\r
- <bundle id="jai.imageio" symbolic-name="org.argeo.dep.osgi.jai.imageio" />\r
---></beans:beans>
\ No newline at end of file
+\r
+ <reference id="backend" interface="org.argeo.slc.geotools.Backend" />\r
+</beans:beans>
\ No newline at end of file
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"
- xmlns:osgi="http://www.springframework.org/schema/osgi"
xsi:schemaLocation="
http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
- http://www.springframework.org/schema/osgi
- http://www.springframework.org/schema/osgi/spring-osgi-1.1.xsd
">
<bean id="org.argeo.slc.client.gis.mapView" class="org.argeo.slc.client.gis.views.GeoToolsMapView"
scope="prototype">
<property name="positionProvider" ref="positionProvider" />
- <property name="postGisDataStore" ref="postGisDataStore" />
- <property name="jaiImageIoClassLoader" ref="jai.imageio.bdClassLoader" />
+ <property name="backend" ref="backend" />
+ <property name="mapContext" ref="mapContext" />
</bean>
- <bean id="jai.imageio.bdClassLoader"
- class="org.springframework.osgi.util.BundleDelegatingClassLoader"
- factory-method="createBundleClassLoaderFor">
- <constructor-arg>
- <osgi:bundle symbolic-name="org.argeo.dep.osgi.jai.imageio" />
- </constructor-arg>
- </bean>
+ <bean id="mapContext" class="org.geotools.map.DefaultMapContext" />
</beans>
package org.argeo.slc.client.gis.views;
+import java.awt.Color;
import java.awt.Frame;
+import java.awt.Graphics2D;
+import java.awt.Rectangle;
+import java.awt.geom.AffineTransform;
+import java.awt.geom.Point2D;
-import org.argeo.slc.geotools.swing.GisFieldViewer;
+import javax.swing.SwingUtilities;
+
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+import org.argeo.slc.geotools.Backend;
+import org.argeo.slc.geotools.DataDescriptor;
+import org.argeo.slc.geotools.data.FeatureSourceDataDescriptor;
+import org.argeo.slc.geotools.data.PostgisDataDescriptor;
+import org.argeo.slc.geotools.data.WorldImageDataDescriptor;
+import org.argeo.slc.geotools.swing.VersatileZoomTool;
+import org.argeo.slc.gis.model.FieldPosition;
import org.argeo.slc.jts.PositionProvider;
import org.eclipse.swt.SWT;
import org.eclipse.swt.awt.SWT_AWT;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.ui.part.ViewPart;
-import org.geotools.data.DataStore;
+import org.geotools.geometry.DirectPosition2D;
+import org.geotools.geometry.Envelope2D;
+import org.geotools.map.MapContext;
+import org.geotools.renderer.lite.StreamingRenderer;
+import org.geotools.styling.RasterSymbolizer;
+import org.geotools.styling.Style;
+import org.geotools.styling.StyleBuilder;
+import org.geotools.swing.JMapPane;
+import org.geotools.swing.event.MapPaneAdapter;
+import org.geotools.swing.event.MapPaneEvent;
+
+import com.vividsolutions.jts.geom.Coordinate;
public class GeoToolsMapView extends ViewPart {
public static final String ID = "org.argeo.slc.client.gis.views.GeoToolsMapView";
+ private final static Log log = LogFactory.getLog(GeoToolsMapView.class);
private Composite embedded;
private PositionProvider positionProvider;
- private DataStore postGisDataStore;
+ private Backend backend;
+
+ private MapContext mapContext;
+ private JMapPane mapPane;
- private ClassLoader jaiImageIoClassLoader;
+ /** in s */
+ private Integer positionRefreshPeriod = 1;
+ private FieldPosition currentPosition = null;
+ private Boolean positionProviderDisconnected = false;
+ private VersatileZoomTool versatileZoomTool;
public void createPartControl(Composite parent) {
embedded = new Composite(parent, SWT.EMBEDDED | SWT.NO_BACKGROUND);
Frame frame = SWT_AWT.new_Frame(embedded);
- GisFieldViewer gisFieldViewer = new GisFieldViewer(frame);
- gisFieldViewer.setPostGisDataStore(postGisDataStore);
- gisFieldViewer.setPositionProvider(positionProvider);
- gisFieldViewer.setJaiImageIoClassLoader(jaiImageIoClassLoader);
- gisFieldViewer.afterPropertiesSet();
+ mapPane = new JMapPane(new StreamingRenderer(), mapContext);
+ versatileZoomTool = new VersatileZoomTool();
+ mapPane.setCursorTool(versatileZoomTool);
+
+ mapPane.addMapPaneListener(new CustomMapPaneListener());
+
+ frame.add(mapPane);
+
+ centerOnPosition();
+
+ for (DataDescriptor dd : backend.getAvailableData(null)) {
+ if (dd instanceof WorldImageDataDescriptor) {
+ StyleBuilder styleBuilder = new StyleBuilder();
+ RasterSymbolizer rs = styleBuilder.createRasterSymbolizer();
+ rs.setGeometryPropertyName("geom");
+ Style rasterStyle = styleBuilder.createStyle(rs);
+ try {
+ mapContext.addLayer(backend.loadGridCoverage(dd),
+ rasterStyle);
+ } catch (Exception e) {
+ log.warn(e);
+ }
+
+ } else if (dd instanceof FeatureSourceDataDescriptor) {
+ try {
+ mapContext.addLayer(backend.loadFeatureSource(dd), null);
+ } catch (Exception e) {
+ log.warn(e);
+ }
+ } else if (dd instanceof PostgisDataDescriptor) {
+ // DataStore dataStore = backend.loadDataStore(dd);
+ for (DataDescriptor dd2 : backend.getAvailableData(dd))
+ mapContext.addLayer(backend.loadFeatureSource(dd2), null);
+ }
+ }
+ // GisFieldViewer gisFieldViewer = new GisFieldViewer(frame);
+ // gisFieldViewer.setPostGisDataStore(postGisDataStore);
+ // gisFieldViewer.setPositionProvider(positionProvider);
+ // gisFieldViewer.setJaiImageIoClassLoader(jaiImageIoClassLoader);
+ // gisFieldViewer.afterPropertiesSet();
+
+ new Thread(new PositionUpdater()).start();
+
+ }
+
+ protected void receiveNewPosition(FieldPosition position) {
+ if (position != null && versatileZoomTool != null) {
+ positionProviderDisconnected = false;
+ currentPosition = position;
+ Point2D point2d = new DirectPosition2D(currentPosition
+ .getLocation().getCoordinate().x, currentPosition
+ .getLocation().getCoordinate().y);
+ versatileZoomTool.setFieldPosition(point2d);
+ drawPositionLocation();
+ } else {
+ positionProviderDisconnected = true;
+ }
+ }
+
+ protected void drawPositionLocation() {
+ SwingUtilities.invokeLater(new Runnable() {
+ public void run() {
+ if (currentPosition == null)
+ return;
+
+ AffineTransform tr = getMapPane().getWorldToScreenTransform();
+ DirectPosition2D geoCoords = new DirectPosition2D(
+ currentPosition.getLocation().getCoordinate().x,
+ currentPosition.getLocation().getCoordinate().y);
+ if (tr == null)
+ return;
+ tr.transform(geoCoords, geoCoords);
+ geoCoords.setCoordinateReferenceSystem(getMapPane()
+ .getMapContext().getCoordinateReferenceSystem());
+
+ final int halfRefSize = 3;
+ Rectangle rect = new Rectangle((int) Math.round(geoCoords
+ .getX() - halfRefSize), (int) Math.round(geoCoords
+ .getY() - halfRefSize), halfRefSize * 2 + 1,
+ halfRefSize * 2 + 1);
+ Graphics2D g2D = (Graphics2D) getMapPane().getGraphics();
+ if (g2D == null)
+ return;
+ g2D.setColor(Color.WHITE);
+ if (positionProviderDisconnected)
+ g2D.setXORMode(Color.ORANGE);
+ else
+ g2D.setXORMode(Color.RED);
+ g2D.drawRect(rect.x, rect.y, rect.width, rect.height);
+ g2D.drawRect(rect.x - 1, rect.y - 1, rect.width + 2,
+ rect.height + 2);
+ }
+ });
+ }
+
+ protected void centerOnPosition() {
+ if (currentPosition == null)
+ return;
+ Envelope2D env = new Envelope2D();
+ final double increment = 1d;
+ Coordinate positionCoo = currentPosition.getLocation().getCoordinate();
+ env.setFrameFromDiagonal(positionCoo.x - increment, positionCoo.y
+ - increment, positionCoo.x + increment, positionCoo.y
+ + increment);
+ getMapPane().setDisplayArea(env);
+
}
public void setFocus() {
embedded.setFocus();
}
+ protected JMapPane getMapPane() {
+ return mapPane;
+ }
+
public void setPositionProvider(PositionProvider positionProvider) {
this.positionProvider = positionProvider;
}
- public void setPostGisDataStore(DataStore postGisDataStore) {
- this.postGisDataStore = postGisDataStore;
+ public void setBackend(Backend backend) {
+ this.backend = backend;
+ }
+
+ public void setMapContext(MapContext mapContext) {
+ this.mapContext = mapContext;
}
- public void setJaiImageIoClassLoader(ClassLoader jaiImageIoClassLoader) {
- this.jaiImageIoClassLoader = jaiImageIoClassLoader;
+ private class CustomMapPaneListener extends MapPaneAdapter {
+
+ @Override
+ public void onRenderingStopped(MapPaneEvent ev) {
+ drawPositionLocation();
+ }
+
+ @Override
+ public void onDisplayAreaChanged(MapPaneEvent ev) {
+ drawPositionLocation();
+ }
+
+ @Override
+ public void onRenderingProgress(MapPaneEvent ev) {
+ drawPositionLocation();
+ }
+
+ @Override
+ public void onRenderingStarted(MapPaneEvent ev) {
+ drawPositionLocation();
+ }
+
+ @Override
+ public void onResized(MapPaneEvent ev) {
+ drawPositionLocation();
+ }
+
+ }
+
+ private class PositionUpdater implements Runnable {
+
+ public void run() {
+ while (true) {
+ FieldPosition currentPosition = positionProvider
+ .currentPosition();
+
+ receiveNewPosition(currentPosition);
+
+ if (currentPosition != null) {
+ }
+
+ try {
+ Thread.sleep(positionRefreshPeriod * 1000);
+ } catch (InterruptedException e) {
+ e.printStackTrace();
+ }
+ }
+ }
}
}
\ No newline at end of file
Import-Package: org.apache.commons.dbcp;version="1.2.2.osgi",
org.argeo.slc.core.deploy;version="0.12.2.SNAPSHOT-r3503",
org.argeo.slc.geotools;version="0.12.2.SNAPSHOT-r3562",
+ org.argeo.slc.geotools.data,
org.argeo.slc.geotools.swing;version="0.12.2.SNAPSHOT-r3565",
+ org.argeo.slc.gis.field,
org.argeo.slc.jts;version="0.12.2.SNAPSHOT-r3562",
org.geotools.data,
org.geotools.data.postgis,
http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">\r
\r
<service ref="postGisDataStore" interface="org.geotools.data.DataStore" />\r
+ <service ref="backend" interface="org.argeo.slc.geotools.Backend" />\r
</beans:beans>
\ No newline at end of file
<?xml version="1.0" encoding="UTF-8"?>\r
<beans xmlns="http://www.springframework.org/schema/beans"\r
- xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"\r
- xmlns:p="http://www.springframework.org/schema/p" xmlns:util="http://www.springframework.org/schema/util"\r
+ xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"\r
+ xmlns:util="http://www.springframework.org/schema/util" xmlns:osgi="http://www.springframework.org/schema/osgi"\r
xsi:schemaLocation="\r
- http://www.springframework.org/schema/beans\r
- http://www.springframework.org/schema/beans/spring-beans-2.5.xsd\r
- http://www.springframework.org/schema/util \r
- http://www.springframework.org/schema/util/spring-util-2.5.xsd\r
+ http://www.springframework.org/schema/beans\r
+ http://www.springframework.org/schema/beans/spring-beans-2.5.xsd\r
+ http://www.springframework.org/schema/util \r
+ http://www.springframework.org/schema/util/spring-util-2.5.xsd\r
+ http://www.springframework.org/schema/osgi \r
+ http://www.springframework.org/schema/osgi/spring-osgi-1.1.xsd\r
">\r
\r
+ <bean id="backend" class="org.argeo.slc.gis.field.FieldBackend"\r
+ init-method="afterPropertiesSet">\r
+ <property name="dataSources">\r
+ <set>\r
+ <ref bean="dataSource" />\r
+ </set>\r
+ </property>\r
+ <!-- <property name="vectors"> <bean class="org.argeo.slc.core.deploy.DefaultResourceSet"> \r
+ <property name="base" value="file:/home/mbaudier/gis/projects/100122-EasternBalkans2010/data" \r
+ /> <property name="include" value="*.shp" /> </bean> </property> <property \r
+ name="rasters"> <bean class="org.argeo.slc.core.deploy.DefaultResourceSet"> \r
+ <property name="base" value="file:/home/mbaudier/gis/data/100501-Poehali" \r
+ /> <property name="include" value="*.gif" /> </bean> </property> -->\r
+ <property name="jaiImageIoClassLoader" ref="jai.imageio.bdClassLoader" />\r
+ </bean>\r
+\r
\r
<bean id="postGisDataStore" factory-bean="postGisDataStoreFactory"\r
factory-method="createDataStore">\r
<constructor-arg>\r
<map>\r
- <!-- Cannot access the .key property, wait for Spring 3.0 to do it properly \r
- <entry key-ref="JDBCDataStore.DATASOURCE" value-ref="dataSource" /> -->\r
- <entry key="Data Source" value-ref="dataSource" />\r
+ <!-- Cannot access the .key property, wait for Spring 3.0 EL to do it \r
+ properly <entry key-ref="JDBCDataStore.DATASOURCE" value-ref="dataSource" \r
+ /> -->\r
+ <entry key="Data Source" value-ref="dataSource" />\r
</map>\r
</constructor-arg>\r
</bean>\r
<property name="maxIdle" value="2" />\r
</bean>\r
\r
+ <bean id="jai.imageio.bdClassLoader"\r
+ class="org.springframework.osgi.util.BundleDelegatingClassLoader"\r
+ factory-method="createBundleClassLoaderFor">\r
+ <constructor-arg>\r
+ <osgi:bundle symbolic-name="org.argeo.dep.osgi.jai.imageio" />\r
+ </constructor-arg>\r
+ </bean>\r
+\r
+\r
</beans>
\ No newline at end of file
--- /dev/null
+package org.argeo.slc.geotools;
+
+import java.util.UUID;
+
+public abstract class AbstractDataDescriptor implements DataDescriptor{
+ private String id;
+ private Boolean isLoaded;
+
+ public AbstractDataDescriptor() {
+ this.id = UUID.randomUUID().toString();
+ this.isLoaded = false;
+ }
+
+ public String getId() {
+ return id;
+ }
+
+ public void setId(String id) {
+ this.id = id;
+ }
+
+ public Boolean getIsLoaded() {
+ return isLoaded;
+ }
+
+ public void setIsLoaded(Boolean isLoaded) {
+ this.isLoaded = isLoaded;
+ }
+
+}
--- /dev/null
+package org.argeo.slc.geotools;
+
+import java.util.Set;
+
+import org.geotools.data.DataStore;
+import org.geotools.data.FeatureSource;
+import org.opengis.coverage.grid.GridCoverage;
+import org.opengis.feature.simple.SimpleFeature;
+import org.opengis.feature.simple.SimpleFeatureType;
+
+public interface Backend {
+
+ public Set<DataDescriptor> getAvailableData(DataDescriptor dataDescriptor);
+
+ public DataStore loadDataStore(DataDescriptor dataDescriptor);
+
+ public FeatureSource<SimpleFeatureType, SimpleFeature> loadFeatureSource(
+ DataDescriptor dataDescriptor);
+
+ public GridCoverage loadGridCoverage(DataDescriptor dataDescriptor);
+}
--- /dev/null
+package org.argeo.slc.geotools;
+
+public interface DataDescriptor {
+ public String getId();
+
+}
--- /dev/null
+package org.argeo.slc.geotools.data;
+
+public interface FeatureSourceDataDescriptor {
+
+}
--- /dev/null
+package org.argeo.slc.geotools.data;
+
+import java.util.Set;
+
+import javax.sql.DataSource;
+
+import org.argeo.slc.geotools.AbstractDataDescriptor;
+
+public class PostgisDataDescriptor extends AbstractDataDescriptor {
+ private DataSource dataSource;
+
+ private Set<PostgisLayerDataDescriptor> layers = null;
+
+ public PostgisDataDescriptor(DataSource dataSource) {
+ super();
+ this.dataSource = dataSource;
+ }
+
+ public DataSource getDataSource() {
+ return dataSource;
+ }
+
+ public Set<PostgisLayerDataDescriptor> getLayers() {
+ return layers;
+ }
+
+ public void setLayers(Set<PostgisLayerDataDescriptor> layers) {
+ this.layers = layers;
+ }
+
+}
--- /dev/null
+package org.argeo.slc.geotools.data;
+
+import org.argeo.slc.geotools.AbstractDataDescriptor;
+
+public class PostgisLayerDataDescriptor extends AbstractDataDescriptor
+ implements FeatureSourceDataDescriptor {
+ private PostgisDataDescriptor postGisDataDescriptor;
+ private String name;
+
+ public PostgisLayerDataDescriptor(
+ PostgisDataDescriptor postgisDataDescriptor, String name) {
+ this.postGisDataDescriptor = postgisDataDescriptor;
+ this.name = name;
+ }
+
+ public String getName() {
+ return name;
+ }
+
+ public PostgisDataDescriptor getPostGisDataDescriptor() {
+ return postGisDataDescriptor;
+ }
+
+}
--- /dev/null
+package org.argeo.slc.geotools.data;
+
+import java.io.IOException;
+
+import org.argeo.slc.geotools.AbstractDataDescriptor;
+import org.springframework.core.io.Resource;
+
+public class VectorDataDescriptor extends AbstractDataDescriptor implements
+ FeatureSourceDataDescriptor {
+ private final Resource resource;
+
+ public VectorDataDescriptor(Resource resource) throws IOException {
+ this.resource = resource;
+ }
+
+ public Resource getResource() {
+ return resource;
+ }
+
+ @Override
+ public String toString() {
+ return resource.toString();
+ }
+
+}
--- /dev/null
+package org.argeo.slc.geotools.data;
+
+import java.io.IOException;
+
+import org.argeo.slc.geotools.AbstractDataDescriptor;
+import org.springframework.core.io.Resource;
+
+public class WorldImageDataDescriptor extends AbstractDataDescriptor {
+ private final Resource resource;
+
+ public WorldImageDataDescriptor(Resource resource) throws IOException {
+ this.resource = resource;
+ }
+
+ public Resource getResource() {
+ return resource;
+ }
+
+ @Override
+ public String toString() {
+ return resource.toString();
+ }
+
+}
import java.io.IOException;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
-import java.util.HashMap;
-import java.util.Map;
import javax.media.jai.JAI;
import javax.sql.DataSource;
import org.geotools.data.FeatureSource;
import org.geotools.data.FileDataStoreFinder;
import org.geotools.data.WorldFileReader;
-import org.geotools.data.postgis.PostgisNGDataStoreFactory;
import org.geotools.factory.CommonFactoryFinder;
import org.geotools.gce.image.WorldImageFormat;
import org.geotools.geometry.DirectPosition2D;
}
try {
- Map params = new HashMap();
- // params.put("dbtype", "postgis");
- // params.put("host", "air");
- // params.put("port", new Integer(5432));
- // params.put("database", "test_berlin");
- // params.put("user", "argeo");
- // params.put("passwd", "argeo");
- //
- // DataStore pgDatastore = DataStoreFinder.getDataStore(params);
-
- PostgisNGDataStoreFactory factory = new PostgisNGDataStoreFactory();
- // JDBCDataStore pgDatastore = new JDBCDataStore();
- // pgDatastore.setDataSource(dataSource);
- // pgDatastore.setSQLDialect(new PostGISDialect(pgDatastore));
-
- params.put(PostgisNGDataStoreFactory.DATASOURCE.key, dataSource);
-
- //JDBCDataStore pgDatastore = factory.createDataStore(params);
-
FeatureSource<SimpleFeatureType, SimpleFeature> source = postGisDataStore
.getFeatureSource("ways");
- // log.debug("source CRS: "+source.getBounds().getCoordinateReferenceSystem());
- // log.debug("context CRS: "+mapContext.getCoordinateReferenceSystem());
-
mapContext.addLayer(source, createLineStyle());
} catch (Exception e) {
log.error("Could not load db " + "" + ": " + e);
.currentPosition();
receiveNewPosition(currentPosition);
- // versatileZoomTool.setFieldPosition(new
- // Point2D(currentPosition
- // .getLocation().getX(), currentPosition.getLocation()
- // .getY()));
if (currentPosition != null) {
-
- // if (mapPane.getDisplayArea().contains(
- // currentPosition.getLocation().getCoordinate())) {
- // SimpleFeature feature = POSITION
- // .buildFeature(currentPosition);
- // FeatureCollection<SimpleFeatureType, SimpleFeature>
- // collection = new DefaultFeatureCollection(
- // "Field Position "
- // + fieldPositionDateFormat
- // .format(currentPosition
- // .getTimestamp()),
- // POSITION.getFeatureType());
- // collection.add(feature);
- // if (mapLayer != null)
- // mapPane.getMapContext().removeLayer(mapLayer);
- // Style style = SLD.createSimpleStyle(POSITION
- // .getFeatureType(), Color.RED);
- // mapLayer = new DefaultMapLayer(collection, style, "");
- // mapPane.getMapContext().addLayer(mapLayer);
- // }
}
try {
int sign = (clicks < 0 ? -1 : 1);
ReferencedEnvelope env = getMapPane().getDisplayArea();
+ if (env == null)
+ return;
double width = env.getWidth();
double delta = width * clickToZoom * sign;
--- /dev/null
+package org.argeo.slc.gis.field;
+
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+
+import javax.media.jai.JAI;
+import javax.sql.DataSource;
+
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+import org.argeo.slc.core.deploy.DefaultResourceSet;
+import org.argeo.slc.core.deploy.ResourceSet;
+import org.argeo.slc.geotools.Backend;
+import org.argeo.slc.geotools.DataDescriptor;
+import org.argeo.slc.geotools.data.PostgisDataDescriptor;
+import org.argeo.slc.geotools.data.PostgisLayerDataDescriptor;
+import org.argeo.slc.geotools.data.VectorDataDescriptor;
+import org.argeo.slc.geotools.data.WorldImageDataDescriptor;
+import org.geotools.data.DataStore;
+import org.geotools.data.FeatureSource;
+import org.geotools.data.FileDataStore;
+import org.geotools.data.FileDataStoreFinder;
+import org.geotools.data.WorldFileReader;
+import org.geotools.data.postgis.PostgisNGDataStoreFactory;
+import org.geotools.gce.image.WorldImageFormat;
+import org.geotools.styling.RasterSymbolizer;
+import org.geotools.styling.StyleBuilder;
+import org.opengis.coverage.grid.GridCoverage;
+import org.opengis.feature.simple.SimpleFeature;
+import org.opengis.feature.simple.SimpleFeatureType;
+import org.opengis.feature.type.Name;
+import org.springframework.core.io.Resource;
+
+public class FieldBackend implements Backend {
+ private final static Log log = LogFactory.getLog(FieldBackend.class);
+
+ private ResourceSet vectors = new DefaultResourceSet();
+ private ResourceSet rasters = new DefaultResourceSet();
+ private Set<DataSource> dataSources = new HashSet<DataSource>();
+
+ private ClassLoader jaiImageIoClassLoader;
+ private PostgisNGDataStoreFactory postgisDataStoreFactory = new PostgisNGDataStoreFactory();
+
+ private Map<String, Object> cache = Collections
+ .synchronizedMap(new HashMap<String, Object>());
+
+ private Set<DataDescriptor> resgisteredData = new HashSet<DataDescriptor>();
+
+ public Set<DataDescriptor> getAvailableData(DataDescriptor dataDescriptor) {
+ Set<DataDescriptor> availableData = new HashSet<DataDescriptor>();
+
+ if (dataDescriptor == null) {
+ return resgisteredData;
+ } else if (dataDescriptor instanceof PostgisDataDescriptor) {
+ PostgisDataDescriptor pdd = (PostgisDataDescriptor) dataDescriptor;
+ if (pdd.getLayers() == null)
+ try {
+ for (Name name : loadDataStore(dataDescriptor).getNames()) {
+ log.info(name);
+// pdd.getLayers().add(
+// new PostgisLayerDataDescriptor(
+// (PostgisDataDescriptor) dataDescriptor,
+// name.getLocalPart()));
+ }
+ pdd.setLayers(new HashSet<PostgisLayerDataDescriptor>());
+ pdd.getLayers().add(
+ new PostgisLayerDataDescriptor(
+ (PostgisDataDescriptor) dataDescriptor,
+ "ways"));
+ } catch (Exception e) {
+ log.warn("Could not children of " + dataDescriptor + ": "
+ + e);
+ }
+ availableData.addAll(pdd.getLayers());
+ }
+ return availableData;
+ }
+
+ public void afterPropertiesSet() {
+ for (Resource vector : vectors.listResources().values()) {
+ try {
+ DataDescriptor dd = new VectorDataDescriptor(vector);
+ resgisteredData.add(dd);
+ } catch (Exception e) {
+ log.warn("Could not load " + vector + ": " + e);
+ }
+ }
+ for (Resource raster : rasters.listResources().values()) {
+ try {
+ DataDescriptor dd = new WorldImageDataDescriptor(raster);
+ resgisteredData.add(dd);
+ } catch (Exception e) {
+ log.warn("Could not load " + raster + ": " + e);
+ }
+ }
+ for (DataSource dataSource : dataSources) {
+ try {
+ DataDescriptor dd = new PostgisDataDescriptor(dataSource);
+ resgisteredData.add(dd);
+ } catch (Exception e) {
+ log.warn("Could not load " + dataSource + ": " + e);
+ }
+ }
+ }
+
+ public DataStore loadDataStore(DataDescriptor dataDescriptor) {
+ if (cache.containsKey(dataDescriptor.getId()))
+ return (DataStore) cache.get(dataDescriptor.getId());
+
+ try {
+ if (dataDescriptor instanceof VectorDataDescriptor) {
+ DataStore ds = FileDataStoreFinder
+ .getDataStore(((VectorDataDescriptor) dataDescriptor)
+ .getResource().getURL());
+ cache(dataDescriptor.getId(), ds);
+ return ds;
+ } else if (dataDescriptor instanceof PostgisDataDescriptor) {
+ DataSource dataSource = ((PostgisDataDescriptor) dataDescriptor)
+ .getDataSource();
+ Map params = new HashMap();
+ params.put(PostgisNGDataStoreFactory.DATASOURCE.key, dataSource);
+ DataStore ds = postgisDataStoreFactory.createDataStore(params);
+ cache(dataDescriptor.getId(), ds);
+ return ds;
+ }
+ } catch (Exception e) {
+ log.error("Could not load " + dataDescriptor + ": " + e);
+ if (log.isTraceEnabled())
+ log.trace("Stack", e);
+ }
+ return null;
+ }
+
+ public FeatureSource<SimpleFeatureType, SimpleFeature> loadFeatureSource(
+ DataDescriptor dataDescriptor) {
+ if (cache.containsKey(dataDescriptor.getId()))
+ return (FeatureSource<SimpleFeatureType, SimpleFeature>) cache
+ .get(dataDescriptor.getId());
+
+ try {
+ if (dataDescriptor instanceof VectorDataDescriptor) {
+ FeatureSource<SimpleFeatureType, SimpleFeature> fs = ((FileDataStore) loadDataStore(dataDescriptor))
+ .getFeatureSource();
+ cache(dataDescriptor.getId(), fs);
+ return fs;
+ } else if (dataDescriptor instanceof PostgisLayerDataDescriptor) {
+ PostgisLayerDataDescriptor pgldd = (PostgisLayerDataDescriptor) dataDescriptor;
+ FeatureSource<SimpleFeatureType, SimpleFeature> fs = loadDataStore(
+ pgldd.getPostGisDataDescriptor()).getFeatureSource(
+ pgldd.getName());
+ cache(dataDescriptor.getId(), fs);
+ return fs;
+ }
+ } catch (Exception e) {
+ log.error("Could not load " + dataDescriptor + ": " + e);
+ if (log.isTraceEnabled())
+ log.trace("Stack", e);
+ }
+ return null;
+ }
+
+ public GridCoverage loadGridCoverage(DataDescriptor dataDescriptor) {
+ if (cache.containsKey(dataDescriptor.getId()))
+ return (GridCoverage) cache.get(dataDescriptor.getId());
+
+ if (jaiImageIoClassLoader == null) {
+ log.warn("No JAI ImageIO class loader available");
+ return null;
+ }
+ ClassLoader currentContextCl = Thread.currentThread()
+ .getContextClassLoader();
+
+ try {
+ if (dataDescriptor instanceof WorldImageDataDescriptor) {
+ Resource raster = ((WorldImageDataDescriptor) dataDescriptor)
+ .getResource();
+
+ Thread.currentThread().setContextClassLoader(
+ jaiImageIoClassLoader);
+ JAI.getDefaultInstance()
+ .getOperationRegistry()
+ .registerServices(
+ WorldFileReader.class.getClassLoader());
+ StyleBuilder styleBuilder = new StyleBuilder();
+ RasterSymbolizer rs = styleBuilder.createRasterSymbolizer();
+ rs.setGeometryPropertyName("geom");
+ WorldImageFormat worldImageFormat = new WorldImageFormat();
+ GridCoverage gridCoverage = worldImageFormat.getReader(
+ raster.getURL()).read(null);
+ cache(dataDescriptor.getId(), gridCoverage);
+ return gridCoverage;
+ }
+ } catch (Exception e) {
+ log.error("Could not load grid coverage " + dataDescriptor + ": "
+ + e);
+ if (log.isTraceEnabled())
+ log.trace("Stack", e);
+ } finally {
+ Thread.currentThread().setContextClassLoader(currentContextCl);
+ }
+ return null;
+ }
+
+ protected void cache(String id, Object obj) {
+ cache.put(id, obj);
+ }
+
+ public void setVectors(ResourceSet vectors) {
+ this.vectors = vectors;
+ }
+
+ public void setRasters(ResourceSet rasters) {
+ this.rasters = rasters;
+ }
+
+ public void setDataSources(Set<DataSource> dataSources) {
+ this.dataSources = dataSources;
+ }
+
+ public void setJaiImageIoClassLoader(ClassLoader jaiImageIoClassLoader) {
+ this.jaiImageIoClassLoader = jaiImageIoClassLoader;
+ }
+
+}
projects / gpl / argeo-slc.git / commitdiff