Hi Oliver:
Andrea sent me over to say hi; I was looking at
http://jira.codehaus.org/browse/GEOT-3051 today (trying to make a few less
casts and generics for those using GeoTools - especially when learning) and he
sent me in your direction.
I am one of the developer enthusiastic about providing a selection of
implementation for datastore implementors; and GeoTools users to work from. And
would be keen to gather up implementations like this for the code base.
Could I ask you to submit this as a patch?
I am also really keen to see an implementation backed onto a JTS Spatial index
:-)
As for DefaultFeatureColleciton it originally had a HashMap which was faster;
but it was changed to a TreeMap (sorted by feature id) to better match
shapefile which also keeps its features in order. What can I say we were
defining an API at a time; and now that it is works we should encourage a range
of implementations to suite different tasks.
Jody
On 21/04/2010, at 7:49 AM, Oliver Gottwald wrote:
> Andrea thanks again for your help. A colleague and I cranked this out a
> little while ago.
>
> The following is a Lean(Low Processing) Solution to population of a
> FeatureCollection:
> Minimal Testing.....
>
> Below is the following: LeanFeatureCollection.java, LeanFeatureSource.java,
> and a snipped from a Test Cast:
>
> //LeanFeatureCollection
>
> package org.geotools.demo;
>
>
> import java.util.ArrayList;
> import java.util.Iterator;
> import java.util.List;
> import java.util.NoSuchElementException;
>
> import org.geotools.feature.FeatureIterator;
> import org.geotools.feature.collection.AbstractFeatureCollection;
> import org.geotools.geometry.jts.ReferencedEnvelope;
> import org.opengis.feature.simple.SimpleFeature;
> import org.opengis.feature.simple.SimpleFeatureType;
> import org.opengis.geometry.BoundingBox;
>
>
>
> @SuppressWarnings("unchecked")
> public class LeanFeatureCollection extends AbstractFeatureCollection {
>
> private List<SimpleFeature> features = new ArrayList<SimpleFeature>();
> private ReferencedEnvelope bounds = null;
>
> protected LeanFeatureCollection(SimpleFeatureType schema) {
> super(schema);
> }
>
>
> @Override
> public int size() {
> return features.size();
> }
>
> @Override
> protected Iterator openIterator() {
> Iterator it = features.iterator();
> return it;
> }
>
> @Override
> protected void closeIterator(Iterator close) {
> // nothing to do there
> }
>
>
> @Override
> public boolean add(SimpleFeature f) {
>
> //maintain the bounds
> BoundingBox boundingBox = f.getBounds();
> if (bounds == null){
> bounds = new ReferencedEnvelope(
> boundingBox.getMinX(), boundingBox.getMaxX(),
> boundingBox.getMinY(), boundingBox.getMaxY(),
> schema.getCoordinateReferenceSystem());
> } else {
> bounds.expandToInclude(boundingBox.getMinX(),
> boundingBox.getMinY());
> bounds.expandToInclude(boundingBox.getMaxX(),
> boundingBox.getMaxY());
> }
>
> return features.add(f);
> }
>
> @Override
> public void clear() {
> // maintain the bounds
> bounds = null;
> super.clear();
> }
>
> @Override
> public FeatureIterator<SimpleFeature> features() {
> return new LeanFeatureCollectionIterator(features);
> }
>
> @Override
> public ReferencedEnvelope getBounds() {
> return bounds;
> }
>
> @Override
> public boolean isEmpty() {
> return features.isEmpty();
> }
>
> private class LeanFeatureCollectionIterator implements
> FeatureIterator<SimpleFeature> {
> private Iterator<SimpleFeature> iter;
>
> public LeanFeatureCollectionIterator(List<SimpleFeature> features) {
> iter = features.iterator();
> }
>
> public void close() {
> // do nothing
> }
>
> public boolean hasNext() {
> return iter.hasNext();
> }
>
> public SimpleFeature next() throws NoSuchElementException {
> return iter.next();
> }
> }
> }
>
>
> //LeanFeatureSource.java
> package org.geotools.demo;
>
> import java.awt.RenderingHints.Key;
> import java.io.IOException;
> import java.util.HashSet;
> import java.util.Set;
>
> import org.geotools.data.DataAccess;
> import org.geotools.data.FeatureListener;
> import org.geotools.data.FeatureSource;
> import org.geotools.data.Query;
> import org.geotools.data.QueryCapabilities;
> import org.geotools.data.ResourceInfo;
> import org.geotools.feature.CollectionListener;
> import org.geotools.feature.FeatureCollection;
> import org.geotools.geometry.jts.ReferencedEnvelope;
> import org.opengis.feature.simple.SimpleFeature;
> import org.opengis.feature.simple.SimpleFeatureType;
> import org.opengis.feature.type.Name;
> import org.opengis.filter.Filter;
>
>
> public class LeanFeatureSource implements FeatureSource<SimpleFeatureType,
> SimpleFeature> {
>
> private LeanFeatureCollection features;
>
> public LeanFeatureSource(LeanFeatureCollection featureCollection) {
> this.features = featureCollection;
> }
>
>
> public void addFeatureListener(FeatureListener listener) {
> // throw new UnsupportedOperationException();
> }
>
> public ReferencedEnvelope getBounds() throws IOException {
> return features.getBounds();
> }
>
> public ReferencedEnvelope getBounds(Query query) throws IOException {
> return features.getBounds();
> }
>
> public int getCount(Query query) throws IOException {
> return features.size();
> }
>
> public DataAccess<SimpleFeatureType, SimpleFeature> getDataStore() {
> return null;
> }
>
> public FeatureCollection<SimpleFeatureType, SimpleFeature> getFeatures()
> throws IOException {
> return features;
> }
>
> public FeatureCollection<SimpleFeatureType, SimpleFeature> getFeatures(
> Query query) throws IOException {
> return features;
> }
>
> public FeatureCollection<SimpleFeatureType, SimpleFeature> getFeatures(
> Filter filter) throws IOException {
> return features;
> }
>
> public ResourceInfo getInfo() {
> return null;
> }
>
> public Name getName() {
> return null;
> }
>
> public QueryCapabilities getQueryCapabilities() {
> return null;
> }
>
> public SimpleFeatureType getSchema() {
> return features.getSchema();
> }
>
> public Set<Key> getSupportedHints() {
> return new HashSet<Key>();
> }
>
> public void removeFeatureListener(FeatureListener listener) {
> // throw new UnsupportedOperationException();
> }
> }
>
>
> //Test Case Snipped
> //let IDE define imports
> //getPointStyle set to null
> public class DisplayPoint {
> static StyleFactory styleFactory =
> CommonFactoryFinder.getStyleFactory(null);
> static FilterFactory filterFactory =
> CommonFactoryFinder.getFilterFactory(null);
>
> static final CoordinateReferenceSystem crs = DefaultGeographicCRS.WGS84;
> static final int MAX_NAME_LENGTH = 20;
>
> public static void main(String[] args) throws Exception {
> DisplayPoint displayPoint = new DisplayPoint();
> //TreeMapHandler - Object I have internally for TreeMap Handling
> TreeMapHandler tmHandler = new TreeMapHandler();
> //data.csv file of xyz points
> //allPoints is a TreeMap of XyzPoint Objects
> TreeMap allPoints = tmHandler.getTreeMap("/data.csv");
>
> LeanFeatureCollection collection =
> displayPoint.getPointFeature(allPoints);
>
> LeanFeatureSource featureSource = new LeanFeatureSource(collection);
> Style pointStyle = displayPoint.createPointStyle();
> MapLayer m = new DefaultMapLayer(featureSource, pointStyle);
>
> MapContext map = new DefaultMapContext();
> map.setTitle("The Point");
> map.addLayer(featureSource, pointStyle);
>
> JMapFrame.showMap(map);
> }
>
>
> public LeanFeatureCollection getPointFeature(TreeMap allPoints) throws
> Exception {
> SimpleFeatureTypeBuilder typeBuilder = new SimpleFeatureTypeBuilder();
> typeBuilder.setName("mytype");
> typeBuilder.setCRS(crs);
> typeBuilder.add("route", Point.class);
> typeBuilder.length(MAX_NAME_LENGTH).add("name", String.class);
> final SimpleFeatureType TYPE = typeBuilder.buildFeatureType();
>
> GeometryFactory factory = JTSFactoryFinder.getGeometryFactory(null);
> SimpleFeatureBuilder featureBuilder = new SimpleFeatureBuilder(TYPE);
>
> LeanFeatureCollection collection = new LeanFeatureCollection(TYPE);
>
> Collection cl = allPoints.values();
> Iterator it = cl.iterator();
> while (it.hasNext()){
> XyzPoint xyz = (XyzPoint)it.next();
> Point point = factory.createPoint( new
> Coordinate(xyz.getX(),xyz.getY()));
>
> featureBuilder.set("name",xyz.getName());
> featureBuilder.add(point);
>
> SimpleFeature f = featureBuilder.buildFeature(null);
>
>
>
> collection.add(f);
> }
> return collection;
> }
>
> private Style createPointStyle() {
> return null;
> }
> }
> ------------------------------------------------------------------------------
> _______________________________________________
> Geotools-gt2-users mailing list
> [email protected]
> https://lists.sourceforge.net/lists/listinfo/geotools-gt2-users
------------------------------------------------------------------------------
_______________________________________________
Geotools-gt2-users mailing list
[email protected]
https://lists.sourceforge.net/lists/listinfo/geotools-gt2-users
