private SimpleFeatureCollection makePointFeatures() throws Exception { Map<Vertex, Double> points = makePoints(); /* Stage the point features in memory */ DefaultFeatureCollection featureCollection = new DefaultFeatureCollection(null, pointSchema); SimpleFeatureBuilder fbuilder = new SimpleFeatureBuilder(pointSchema); GeometryFactory gf = new GeometryFactory(); for (Map.Entry<Vertex, Double> entry : points.entrySet()) { Vertex vertex = entry.getKey(); Double travelTime = entry.getValue(); fbuilder.add(gf.createPoint(vertex.getCoordinate())); fbuilder.add(travelTime); featureCollection.add(fbuilder.buildFeature(null)); } return featureCollection; }
public void testAppend() throws Exception { SimpleFeatureType type = DataUtilities.createType("trees", "the_geom:Point,FID:String,NAME:String"); SimpleFeatureBuilder sfb = new SimpleFeatureBuilder(type); WKTReader reader = new WKTReader(); sfb.set("the_geom", reader.read("POINT (0.002 0.0008)")); sfb.set("FID", "023"); sfb.set("NAME", "Old oak"); SimpleFeature feature = sfb.buildFeature(null); SimpleFeatureCollection fc = DataUtilities.collection(feature);
SimpleFeature reproject(SimpleFeature feature) throws IOException { Object[] attributes = new Object[schema.getAttributeCount()]; AttributeDescriptor type = schema.getDescriptor(i); Object object = feature.getAttribute(type.getName()); SimpleFeature f = SimpleFeatureBuilder.build(schema, attributes, feature.getID()); f.getUserData().putAll(feature.getUserData()); return f; } catch (IllegalAttributeException e) {
/** * 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; }
static SimpleFeature retype(SimpleFeature source, SimpleFeatureBuilder builder) throws IllegalAttributeException { SimpleFeatureType target = builder.getFeatureType(); for (int i = 0; i < target.getAttributeCount(); i++) { AttributeDescriptor attributeType = target.getDescriptor(i); Object value = null; if (source.getFeatureType().getDescriptor(attributeType.getName()) != null) { value = source.getAttribute(attributeType.getName()); } builder.add(value); } FeatureId id = reTypeId(source.getIdentifier(), source.getFeatureType(), target); SimpleFeature retyped = builder.buildFeature(id.getID()); retyped.getUserData().putAll(source.getUserData()); return retyped; }
public void testExecutePoint() throws Exception { SimpleFeatureTypeBuilder tb = new SimpleFeatureTypeBuilder(); tb.setName("featureType"); tb.add("geometry", Geometry.class); tb.add("integer", Integer.class); GeometryFactory gf = new GeometryFactory(); SimpleFeatureBuilder b = new SimpleFeatureBuilder(tb.buildFeatureType()); DefaultFeatureCollection features = new DefaultFeatureCollection(null, b.getFeatureType()); for (int i = 0; i < 2; i++) { b.add(gf.createPoint(new Coordinate(i, i))); b.add(i); features.add(b.buildFeature(i + "")); } Double distance = new Double(500); BufferFeatureCollection process = new BufferFeatureCollection(); SimpleFeatureCollection output = process.execute(features, distance, null); assertEquals(2, output.size()); SimpleFeatureIterator iterator = output.features(); for (int i = 0; i < 2; i++) { Geometry expected = gf.createPoint(new Coordinate(i, i)).buffer(distance); SimpleFeature sf = iterator.next(); assertTrue(expected.equals((Geometry) sf.getDefaultGeometry())); } }
@Test public void testShapeFileWriterWithSelfCreatedContent() throws IOException { String outFile = utils.getOutputDirectory() + "/test.shp"; SimpleFeatureTypeBuilder b = new SimpleFeatureTypeBuilder(); b.setName("EvacuationArea"); b.setCRS(DefaultGeographicCRS.WGS84); b.add("the_geom", MultiPolygon.class); b.add("name", String.class); SimpleFeatureType ft = b.buildFeatureType(); GeometryFactory geofac = new GeometryFactory(); LinearRing lr = geofac.createLinearRing(new Coordinate[]{new Coordinate(0,0),new Coordinate(0,1),new Coordinate(1,1),new Coordinate(0,0)}); Polygon p = geofac.createPolygon(lr,null); MultiPolygon mp = geofac.createMultiPolygon(new Polygon[]{p}); Collection<SimpleFeature> features = new ArrayList<SimpleFeature>(); features.add(SimpleFeatureBuilder.build(ft, new Object[]{mp,"test_name"},"fid")); Geometry g0 = (Geometry) features.iterator().next().getDefaultGeometry(); SimpleFeatureCollection fts1 = s1.getFeatures(); SimpleFeatureIterator it1 = fts1.features(); SimpleFeature ft1 = it1.next(); Geometry g1 = (Geometry) ft1.getDefaultGeometry();
public void testBounds() throws Exception { PrecisionModel pm = new PrecisionModel(); Geometry[] g = new Geometry[4]; GeometryFactory gf = new GeometryFactory(pm); g[0] = gf.createPoint(new Coordinate(0, 0)); g[1] = gf.createPoint(new Coordinate(0, 10)); g[2] = gf.createPoint(new Coordinate(10, 0)); g[3] = gf.createPoint(new Coordinate(10, 10)); GeometryCollection gc = gf.createGeometryCollection(g); SimpleFeatureTypeBuilder tb = new SimpleFeatureTypeBuilder(); tb.setName("bounds"); tb.setCRS(null); tb.add("p1", Point.class); SimpleFeatureType t = tb.buildFeatureType(); SimpleFeatureCollection fc = FeatureCollections.newCollection(); SimpleFeatureBuilder b = new SimpleFeatureBuilder(t); for (int i = 0; i < g.length; i++) { b.add(g[i]); fc.add(b.buildFeature(null)); } assertEquals(gc.getEnvelopeInternal(), fc.getBounds()); }
SimpleFeatureType ft = ftb.buildFeatureType(); GeometryFactory gf = new GeometryFactory(); SimpleFeatureBuilder sbb = new SimpleFeatureBuilder(ft); track.getFeatureCollection().add(sbb.buildFeature("id1", new Object[]{ gf.createPoint(new Coordinate(0, 0)), 1.2, 2.3 })); track.getFeatureCollection().add(sbb.buildFeature("id2", new Object[]{ gf.createPoint(new Coordinate(3, 0)), 3.4, 4.5 })); track.getFeatureCollection().add(sbb.buildFeature("id3", new Object[]{ gf.createPoint(new Coordinate(0, 3)), 5.6, 6.7 })); track.getFeatureCollection().add(sbb.buildFeature("id4", new Object[]{ gf.createPoint(new Coordinate(3, 3)), 7.8,
public void testBuffer() { SimpleFeatureTypeBuilder builder = new SimpleFeatureTypeBuilder(); builder.setCRS(null); builder.add("geometry", Polygon.class); builder.add("distance", Float.class); builder.setName("schema"); coords[0] = new Coordinate(0, 0); coords[1] = new Coordinate(10, 0); coords[2] = new Coordinate(10, 10); coords[3] = new Coordinate(0, 10); coords[4] = new Coordinate(0, 0); GeometryFactory gf = new GeometryFactory(new PrecisionModel()); LinearRing ring = gf.createLinearRing(coords); attributes[0] = gf.createPolygon(ring, null); attributes[1] = new Float(100.0); SimpleFeature feature = SimpleFeatureBuilder.build(schema, attributes, null);
SimpleFeature createFeatureSized(int sizeNum) { SimpleFeatureTypeBuilder ftb = new SimpleFeatureTypeBuilder(); ftb.setName("geotools"); ftb.add("size", Integer.class); SimpleFeatureBuilder fb = new SimpleFeatureBuilder(ftb.buildFeatureType()); fb.set("size", sizeNum); SimpleFeature feature = fb.buildFeature(null); return feature; } }
SimpleFeatureTypeBuilder tb = new SimpleFeatureTypeBuilder(); GeometryDescriptor gd = fc.getSchema().getGeometryDescriptor(); tb.add(gd.getName().getLocalPart(), Polygon.class, gd.getCoordinateReferenceSystem()); tb.setName("bufferedCollection"); SimpleFeatureType schema = tb.buildFeatureType(); SimpleFeatureBuilder fb = new SimpleFeatureBuilder(schema); ListFeatureCollection result = new ListFeatureCollection(schema); SimpleFeatureIterator fi = fc.features(); while (fi.hasNext()) { SimpleFeature f = fi.next(); fb.add(((Geometry) f.getDefaultGeometry()).buffer(distance)); result.add(fb.buildFeature(null));
@Test public void testImportAllWithDifferentFeatureTypesAndDestPathAndAdd() throws Exception { SimpleFeatureTypeBuilder builder = new SimpleFeatureTypeBuilder(); builder.setCRS(CRS.decode("EPSG:4326")); builder.add("geom", Point.class); builder.add("label", String.class); builder.setName("dest"); SimpleFeatureType type = builder.buildFeatureType(); GeometryFactory gf = new GeometryFactory(); SimpleFeature feature = SimpleFeatureBuilder.build(type, new Object[] { gf.createPoint(new Coordinate(0, 0)), "feature0" }, "feature");
/** * * <!-- begin-user-doc --> * <!-- end-user-doc --> * * @generated modifiable */ public Object parse(ElementInstance instance, Node node, Object value) throws Exception { // retype from the abstract feature type, since extended data could have altered the schema // placemarks add an additional geometry field SimpleFeature feature = (SimpleFeature) value; SimpleFeatureType abstractFeatureType = feature.getFeatureType(); SimpleFeatureTypeBuilder tb = new SimpleFeatureTypeBuilder(); tb.init(abstractFeatureType); tb.setName("placemark"); tb.add("Geometry", Geometry.class); tb.setDefaultGeometry("Geometry"); SimpleFeatureType placemarkFeatureType = tb.buildFeatureType(); SimpleFeatureBuilder b = new SimpleFeatureBuilder(placemarkFeatureType); b.init(feature); // <element minOccurs="0" ref="kml:Geometry"/> for (Object childObj : node.getChildren(Geometry.class)) { Node childNode = (Node) childObj; String componentName = childNode.getComponent().getName(); if (SUPPORTED_GEOMETRY_TYPES.contains(componentName)) { b.set("Geometry", childNode.getValue()); } } return b.buildFeature(feature.getID()); }
public SimpleFeature next() throws NoSuchElementException { SimpleFeature feature = delegate.next(); for (Definition def : definition) { Object value = def.expression.evaluate(feature); fb.add(value); } SimpleFeature created = fb.buildFeature(feature.getID()); return created; } }
@Override public SimpleFeature interpretLine(String[] tokens, SimpleFeatureBuilder builder, SimpleFeatureType simpleFeatureType) throws IOException, ConversionException, TransformException { int attributeIndex = 0; for (int columnIndex = 0; columnIndex < tokens.length; columnIndex++) { String token = tokens[columnIndex]; if (columnIndex == latIndex) { lat = Double.parseDouble(token); } else if (columnIndex == lonIndex) { lon = Double.parseDouble(token); } setAttributeValue(builder, simpleFeatureType, attributeIndex, token); attributeIndex++; } builder.set("geometry", new GeometryFactory().createPoint(new Coordinate(lon, lat))); String featureId = getFeatureId(tokens); return builder.buildFeature(featureId); }
protected void setUp() throws Exception { SimpleFeatureTypeBuilder typeBuilder = new SimpleFeatureTypeBuilder(); typeBuilder.setName("test"); typeBuilder.add("point", Point.class, (CoordinateReferenceSystem) null); typeBuilder.add("integer", Integer.class); typeBuilder.add("float", Float.class); SimpleFeatureType featureType = typeBuilder.buildFeatureType(); builder = new SimpleFeatureBuilder(featureType); builder.setValidating(true); }
SimpleFeatureTypeBuilder b = new SimpleFeatureTypeBuilder(); b.setName( "LineFeature" ); b.setCRS( DefaultGeographicCRS.WGS84 ); // set crs first b.add( "line", LineString.class ); // then add geometry double lonEnd = 9.4; coordinates[0] = new Coordinate(lonStart, latStart); coordinates[1] = new Coordinate(lonEnd, latEnd); LineString line = gFac.createLineString(coordinates ); featureBuilderLines.add(line); SimpleFeature featureLine = featureBuilderLines.buildFeature(null); collectionLines.add(featureLine);
public boolean hasNext() { while (next == null && delegate.hasNext()) { boolean clippedOut = false; SimpleFeature f = delegate.next(); for (AttributeDescriptor ad : f.getFeatureType().getAttributeDescriptors()) { Object attribute = f.getAttribute(ad.getName()); if (ad instanceof GeometryDescriptor) { Class target = ad.getType().getBinding(); attribute = clipGeometry( target, ((GeometryDescriptor) ad).getCoordinateReferenceSystem()); if (attribute == null && f.getFeatureType().getGeometryDescriptor() == ad) { fb.reset(); clippedOut = true; break; fb.add(attribute); next = fb.buildFeature(f.getID()); fb.reset();
public SimpleFeature createPoint(final Coord coordinate, final Object[] attributeValues, final String id) { Point p = this.fac.createPoint(new Coordinate(coordinate.getX(), coordinate.getY())); this.builder.add(p); for (int i = 0; i < attributeValues.length; i++) { Object value = attributeValues[i]; this.builder.add(value); } return this.builder.buildFeature(id); }