Refine search
/** * Create a geotools feature collection from a list of isochrones in the OTPA internal format. * Once in a FeatureCollection, they can for example be exported as GeoJSON. */ public static SimpleFeatureCollection makeContourFeatures(List<IsochroneData> isochrones) { DefaultFeatureCollection featureCollection = new DefaultFeatureCollection(null, contourSchema); SimpleFeatureBuilder fbuilder = new SimpleFeatureBuilder(contourSchema); for (IsochroneData isochrone : isochrones) { fbuilder.add(isochrone.geometry); fbuilder.add(isochrone.cutoffSec); featureCollection.add(fbuilder.buildFeature(null)); } return featureCollection; }
tb.add("geom", Point.class); SimpleFeatureBuilder b = new SimpleFeatureBuilder(tb.buildFeatureType()); b.add(new WKTReader().read("POINT(1 1)")); SimpleFeature f = b.buildFeature(null); f.getUserData().put("foo", "bar"); DefaultFeatureCollection features = new DefaultFeatureCollection(null, b.getFeatureType()); features.add(f); FeatureIterator it = features.features(); assertEquals("bar", it.next().getUserData().get("foo")); } finally { it.close(); assertEquals("bar", it.next().getUserData().get("foo")); } finally { it.close();
public SimpleFeatureCollection collection() throws IOException { DefaultFeatureCollection copy = new DefaultFeatureCollection(null, getSchema()); List<SimpleFeature> list = new ArrayList<SimpleFeature>(contents.size()); SimpleFeatureIterator iterator = features(); try { while (iterator.hasNext()) { SimpleFeature feature = iterator.next(); SimpleFeature duplicate; try { duplicate = SimpleFeatureBuilder.copy(feature); } catch (IllegalAttributeException e) { throw new DataSourceException("Unable to copy " + feature.getID(), e); } list.add(duplicate); } } finally { iterator.close(); } copy.addAll(list); return copy; }
/** * Copies the provided features into a FeatureCollection. * * <p>Often used when gathering a SimpleFeatureCollection into memory. * * @param list features to add to a new FeatureCollection * @return FeatureCollection */ public static SimpleFeatureCollection collection(List<SimpleFeature> list) { DefaultFeatureCollection collection = new DefaultFeatureCollection(null, null); for (SimpleFeature feature : list) { collection.add(feature); } return collection; }
public boolean addAll(FeatureCollection<?, ?> collection) { // TODO check inheritance with FeatureType here!!! boolean changed = false; FeatureIterator<?> iterator = collection.features(); try { while (iterator.hasNext()) { SimpleFeature f = (SimpleFeature) iterator.next(); boolean added = add(f, false); changed |= added; } return changed; } finally { iterator.close(); } }
SimpleFeatureBuilder b = new SimpleFeatureBuilder(tb.buildFeatureType()); DefaultFeatureCollection features = new DefaultFeatureCollection(null, b.getFeatureType()); DefaultFeatureCollection secondFeatures = new DefaultFeatureCollection(null, b .getFeatureType()); b.add(0); secondFeatures.add(b.buildFeature(numFeatures + "")); Coordinate centre = ((Polygon) secondFeatures.features().next().getDefaultGeometry()) .getCentroid().getCoordinate(); Point p = gf.createPoint(centre); b.add(0); features.add(b.buildFeature(0 + "")); SimpleFeatureIterator iterator = output.features(); Geometry expected = (Geometry) features.features().next().getDefaultGeometry(); SimpleFeature sf = iterator.next(); assertTrue(expected.equals((Geometry) sf.getDefaultGeometry()));
public void testSerialTransactions() throws IOException { SimpleFeatureStore st = (SimpleFeatureStore) dataStore.getFeatureSource(tname("ft1")); SimpleFeatureBuilder b = new SimpleFeatureBuilder(st.getSchema()); b.set(aname("intProperty"), Integer.valueOf(100)); SimpleFeature f1 = b.buildFeature(null); DefaultFeatureCollection features = new DefaultFeatureCollection(null, null); features.add(f1); try (Transaction tx1 = new DefaultTransaction()) { st.setTransaction(tx1); st.addFeatures(features); tx1.commit(); } assertEquals(4, dataStore.getFeatureSource(tname("ft1")).getCount(Query.ALL)); try (Transaction tx2 = new DefaultTransaction()) { st.setTransaction(tx2); st.addFeatures(features); tx2.commit(); } assertEquals(5, dataStore.getFeatureSource(tname("ft1")).getCount(Query.ALL)); } }
void addFeatures(FeatureStore fs, FeatureCollection features) throws Exception { SimpleFeatureBuilder b = new SimpleFeatureBuilder((SimpleFeatureType) fs.getSchema()); DefaultFeatureCollection toAdd = new DefaultFeatureCollection(null, null); FeatureIterator it = features.features(); try { SimpleFeature f = null; int i = 0; while (it.hasNext()) { f = (SimpleFeature) it.next(); b.init(f); b.add(f.getAttribute("pointProperty")); b.add(i++); toAdd.add(b.buildFeature(null)); } } finally { it.close(); } fs.addFeatures(toAdd); }
File shp = File.createTempFile("Shape_" + uuid, ".shp"); shp.deleteOnExit(); while (iterator.hasNext()) { SimpleFeature sf = (SimpleFeature) iterator.next(); builder.setDefaultGeometry(sf.getDefaultGeometryProperty() .getName().getLocalPart()); Property geomProperty = sf.getDefaultGeometryProperty(); if(g instanceof MultiPolygon){ GeometryAttribute oldGeometryDescriptor = sf.getDefaultGeometryProperty(); GeometryType type1 = new GeometryTypeImpl(geomProperty.getName(),MultiPolygon.class, oldGeometryDescriptor.getType().getCoordinateReferenceSystem(),oldGeometryDescriptor.getType().isIdentified(),oldGeometryDescriptor.getType().isAbstract(),oldGeometryDescriptor.getType().getRestrictions(),oldGeometryDescriptor.getType().getSuper(),oldGeometryDescriptor.getType().getDescription()); build = new SimpleFeatureBuilder(type); modifiedFeatureCollection = new DefaultFeatureCollection("fc", type); build.add(sf.getProperty(attributeType.getName()).getValue()); SimpleFeature newSf = build.buildFeature(sf.getIdentifier() .getID());
DefaultFeatureCollection result = new DefaultFeatureCollection(null, targetSchema); SimpleFeatureBuilder fb = new SimpleFeatureBuilder((SimpleFeatureType) result.getSchema()); FeatureIterator fi = features.features(); try { int counter = 0; while (fi.hasNext()) { fb.init((SimpleFeature) fi.next()); SimpleFeature feature = fb.buildFeature(null); result.add(feature); fi.close();
final FeatureIterator<SimpleFeature> featureIterator = featureCollection.features(); List<Coordinate> coordList = new ArrayList<Coordinate>(); while (featureIterator.hasNext()) { final SimpleFeature feature = featureIterator.next(); final Point pt = (Point) feature.getDefaultGeometry(); coordList.add(pt.getCoordinate()); if (isClosedPolygon(coordList)) { featureType = DataUtilities.createType("Geometry", "geometry:Polygon"); featureBuilder = new SimpleFeatureBuilder(featureType); feature = featureBuilder.buildFeature(Integer.toString(coordList.size() + 1)); final LinearRing polygon = geometryFactory.createLinearRing(coordList.toArray(new Coordinate[coordList.size()])); feature.setDefaultGeometry(polygon); } else { featureType = DataUtilities.createType("Geometry", "geometry:LineString"); featureBuilder = new SimpleFeatureBuilder(featureType); feature = featureBuilder.buildFeature(Integer.toString(coordList.size() + 1)); final LineString lineString = geometryFactory.createLineString(coordList.toArray(new Coordinate[coordList.size()])); feature.setDefaultGeometry(lineString); new DefaultFeatureCollection(featureCollection.getID() + "_vertex", featureType); vertexCollection.add(feature);
public void testSetFeatures() throws IOException { SimpleFeatureBuilder b = new SimpleFeatureBuilder(featureStore.getSchema()); DefaultFeatureCollection collection = new DefaultFeatureCollection(null, featureStore.getSchema()); for (int i = 3; i < 6; i++) { b.set(aname("intProperty"), Integer.valueOf(i)); b.set(aname("geometry"), new GeometryFactory().createPoint(new Coordinate(i, i))); collection.add(b.buildFeature(null)); } try (FeatureReader<SimpleFeatureType, SimpleFeature> reader = new CollectionFeatureReader( (SimpleFeatureCollection) collection, collection.getSchema())) { featureStore.setFeatures(reader); } SimpleFeatureCollection features = featureStore.getFeatures(); assertEquals(3, features.size()); try (SimpleFeatureIterator iterator = features.features()) { HashSet<Integer> numbers = new HashSet<Integer>(); numbers.add(Integer.valueOf(3)); numbers.add(Integer.valueOf(4)); numbers.add(Integer.valueOf(5)); for (int i = 3; iterator.hasNext(); i++) { SimpleFeature feature = (SimpleFeature) iterator.next(); assertTrue( numbers.contains( ((Number) feature.getAttribute(aname("intProperty"))).intValue())); numbers.remove(feature.getAttribute(aname("intProperty"))); } } }
public void testAddFeatures() throws IOException { SimpleFeatureBuilder b = new SimpleFeatureBuilder(featureStore.getSchema()); DefaultFeatureCollection collection = new DefaultFeatureCollection(null, featureStore.getSchema()); b.set(aname("intProperty"), Integer.valueOf(i)); b.set(aname("geometry"), new GeometryFactory().createPoint(new Coordinate(i, i))); collection.add(b.buildFeature(null)); assertEquals(watcher.bounds, collection.getBounds()); assertEquals(fid, feature.getID()); assertFalse(iterator.hasNext());
FeatureCollection result = new DefaultFeatureCollection(null, targetSchema); SimpleFeatureBuilder fb = new SimpleFeatureBuilder((SimpleFeatureType) result.getSchema()); FeatureIterator fi = features.features(); try { int counter = 0; while( fi.hasNext() ) { fb.init((SimpleFeature) fi.next()); SimpleFeature feature = fb.buildFeature(null);
SimpleFeatureBuilder b = new SimpleFeatureBuilder(featureStore.getSchema()); DefaultFeatureCollection collection = new DefaultFeatureCollection(null, featureStore.getSchema()); String typeName = b.getFeatureType().getTypeName(); for (int i = 3; i < 6; i++) { b.set(aname("intProperty"), Integer.valueOf(i)); b.set(aname("geometry"), new GeometryFactory().createPoint(new Coordinate(i, i))); b.featureUserData(Hints.USE_PROVIDED_FID, Boolean.TRUE); collection.add(b.buildFeature(typeName + "." + (i * 10)));
private VectorDataNode[] createVectorDataNodes(FeatureCollection<SimpleFeatureType, SimpleFeature> productFeatures) { final FeatureIterator<SimpleFeature> featureIterator = productFeatures.features(); final List<VectorDataNode> result = new ArrayList<VectorDataNode>(); while (featureIterator.hasNext()) { final SimpleFeature simpleFeature = featureIterator.next(); final DefaultFeatureCollection fc = new DefaultFeatureCollection(simpleFeature.getID(), simpleFeature.getFeatureType()); fc.add(simpleFeature); String name = Util.getFeatureName(simpleFeature); result.add(new VectorDataNode(name, fc)); } return result.toArray(new VectorDataNode[result.size()]); }
transformer.setMathTransform(mathTransform); final FeatureCollection<SimpleFeatureType, SimpleFeature> sourceCollection = sourceVectorDataNode.getFeatureCollection(); final DefaultFeatureCollection targetCollection = new DefaultFeatureCollection(sourceCollection.getID(), sourceCollection.getSchema()); final FeatureIterator<SimpleFeature> featureIterator = sourceCollection.features(); while (featureIterator.hasNext()) { final SimpleFeature srcFeature = featureIterator.next(); final Object defaultGeometry = srcFeature.getDefaultGeometry(); if (defaultGeometry != null && defaultGeometry instanceof Geometry) { try { final Geometry transformedGeometry = transformer.transform((Geometry) defaultGeometry); final SimpleFeature targetFeature = SimpleFeatureBuilder.copy(srcFeature); targetFeature.setDefaultGeometry(transformedGeometry); targetCollection.add(targetFeature); } catch (TransformException e) { return null; targetVectorDataNode.getFeatureCollection().addAll((FeatureCollection<?, ?>) targetCollection); targetVectorDataNode.setDefaultStyleCss(sourceVectorDataNode.getDefaultStyleCss()); targetVectorDataNode.setDescription(sourceVectorDataNode.getDescription());
@Test public void testDecodingDelimiter() throws IOException { final FeatureCollection<SimpleFeatureType, SimpleFeature> readCollection = VectorDataNodeReader.read("mem", new StringReader(stringWriter.toString()), createDummyProduct(), new FeatureUtils.FeatureCrsProvider() { @Override public CoordinateReferenceSystem getFeatureCrs(Product product) { return DefaultGeographicCRS.WGS84; } }, placemarkDescriptorProvider, DefaultGeographicCRS.WGS84, VectorDataNodeIO.DEFAULT_DELIMITER_CHAR, ProgressMonitor.NULL).getFeatureCollection(); assertEquals(testCollection.size(), readCollection.size()); final FeatureIterator<SimpleFeature> expectedIterator = testCollection.features(); final FeatureIterator<SimpleFeature> actualIterator = readCollection.features(); while (expectedIterator.hasNext()) { final SimpleFeature expectedFeature = expectedIterator.next(); final SimpleFeature actualFeature = actualIterator.next(); final Object expectedAttribute = expectedFeature.getAttribute(ATTRIBUTE_NAME_LABEL); final Object actualAttribute = actualFeature.getAttribute(ATTRIBUTE_NAME_LABEL); assertEquals(expectedAttribute, actualAttribute); } }
protected void setUp() throws Exception { SimpleFeatureTypeBuilder tb = new SimpleFeatureTypeBuilder(); tb.setName("Dummy"); SimpleFeatureBuilder b = new SimpleFeatureBuilder(tb.buildFeatureType()); for (int i = 0; i < 100; i++) { features.add(b.buildFeature(null)); } }
@Before public void setUp() throws Exception { SimpleFeatureType schema = createNiceMock(SimpleFeatureType.class); expect(schema.getTypeName()).andReturn("testSchema").anyTimes(); expect(schema.getName()).andReturn(new NameImpl("testSchema")).anyTimes(); replay(schema); feature = createNiceMock(SimpleFeature.class); expect(feature.getID()).andReturn("testSchema.1").anyTimes(); expect(feature.getType()).andReturn(schema).anyTimes(); expect(feature.getFeatureType()).andReturn(schema).anyTimes(); replay(feature); DefaultFeatureCollection fc = new DefaultFeatureCollection(); fc.add(feature); store = createNiceMock(FeatureStore.class); expect(store.getSchema()).andReturn(schema).anyTimes(); expect(store.getFeatures()).andReturn(fc).anyTimes(); expect(store.getFeatures((Filter) anyObject())).andReturn(fc).anyTimes(); expect(store.getFeatures((Query) anyObject())).andReturn(fc).anyTimes(); replay(store); /*expect(fc.features()).andReturn(it).anyTimes(); expect(fc.sort(sort)).andReturn(fc).anyTimes(); expect(fc.subCollection(Filter.INCLUDE)).andReturn(fc).anyTimes(); expect(fc.getSchema()).andReturn(schema).anyTimes(); replay(fc);*/ }