Examples with SimpleFeature org.opengis.feature.simple.SimpleFeature used on opensource projects

Example 21 with SimpleFeature

use of org.opengis.feature.simple.SimpleFeature in project GeoGig by boundlessgeo.

the class OSMExport method getFeatures.

private Iterator<EntityContainer> getFeatures(String ref) {
    Optional<ObjectId> id = geogig.command(RevParse.class).setRefSpec(ref).call();
    if (!id.isPresent()) {
        return Iterators.emptyIterator();
    }
    LsTreeOp op = geogig.command(LsTreeOp.class).setStrategy(Strategy.DEPTHFIRST_ONLY_FEATURES).setReference(ref);
    if (bbox != null) {
        final Envelope env;
        try {
            env = new Envelope(Double.parseDouble(bbox.get(0)), Double.parseDouble(bbox.get(2)), Double.parseDouble(bbox.get(1)), Double.parseDouble(bbox.get(3)));
        } catch (NumberFormatException e) {
            throw new IllegalArgumentException("Wrong bbox definition");
        }
        Predicate<Bounded> filter = new Predicate<Bounded>() {

            @Override
            public boolean apply(final Bounded bounded) {
                boolean intersects = bounded.intersects(env);
                return intersects;
            }
        };
        op.setBoundsFilter(filter);
    }
    Iterator<NodeRef> iterator = op.call();
    final EntityConverter converter = new EntityConverter();
    Function<NodeRef, EntityContainer> function = new Function<NodeRef, EntityContainer>() {

        @Override
        @Nullable
        public EntityContainer apply(@Nullable NodeRef ref) {
            RevFeature revFeature = geogig.command(RevObjectParse.class).setObjectId(ref.objectId()).call(RevFeature.class).get();
            SimpleFeatureType featureType;
            if (ref.path().startsWith(OSMUtils.NODE_TYPE_NAME)) {
                featureType = OSMUtils.nodeType();
            } else {
                featureType = OSMUtils.wayType();
            }
            SimpleFeatureBuilder featureBuilder = new SimpleFeatureBuilder(featureType);
            RevFeatureType revFeatureType = RevFeatureTypeImpl.build(featureType);
            List<PropertyDescriptor> descriptors = revFeatureType.sortedDescriptors();
            ImmutableList<Optional<Object>> values = revFeature.getValues();
            for (int i = 0; i < descriptors.size(); i++) {
                PropertyDescriptor descriptor = descriptors.get(i);
                Optional<Object> value = values.get(i);
                featureBuilder.set(descriptor.getName(), value.orNull());
            }
            SimpleFeature feature = featureBuilder.buildFeature(ref.name());
            Entity entity = converter.toEntity(feature, null);
            EntityContainer container;
            if (entity instanceof Node) {
                container = new NodeContainer((Node) entity);
            } else {
                container = new WayContainer((Way) entity);
            }
            return container;
        }
    };
    return Iterators.transform(iterator, function);
}

Example 22 with SimpleFeature

use of org.opengis.feature.simple.SimpleFeature in project GeoGig by boundlessgeo.

the class ImportOpTest method testImportAllWithDifferentFeatureTypesAndDestPathAndAdd.

@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");
    geogig.getRepository().workingTree().insert("dest", feature);
    ImportOp importOp = geogig.command(ImportOp.class);
    importOp.setDataStore(TestHelper.createTestFactory().createDataStore(null));
    importOp.setAll(true);
    importOp.setOverwrite(false);
    importOp.setDestinationPath("dest");
    importOp.setAdaptToDefaultFeatureType(false);
    importOp.call();
    Iterator<NodeRef> features = geogig.command(LsTreeOp.class).setStrategy(Strategy.DEPTHFIRST_ONLY_FEATURES).call();
    ArrayList<NodeRef> list = Lists.newArrayList(features);
    assertEquals(5, list.size());
    TreeSet<ObjectId> set = Sets.newTreeSet();
    ArrayList<RevFeatureType> ftlist = new ArrayList<RevFeatureType>();
    for (NodeRef node : list) {
        Optional<RevFeatureType> ft = geogig.command(RevObjectParse.class).setObjectId(node.getMetadataId()).call(RevFeatureType.class);
        assertTrue(ft.isPresent());
        ftlist.add(ft.get());
        set.add(node.getMetadataId());
    }
    assertEquals(4, set.size());
}

Example 23 with SimpleFeature

use of org.opengis.feature.simple.SimpleFeature in project graphhopper by graphhopper.

the class OSMShapeFileReader method processRoads.

@Override
void processRoads() {
    DataStore dataStore = null;
    FeatureIterator<SimpleFeature> roads = null;
    try {
        dataStore = openShapefileDataStore(roadsFile, encoding);
        roads = getFeatureIterator(dataStore);
        while (roads.hasNext()) {
            SimpleFeature road = roads.next();
            for (Coordinate[] points : getCoords(road.getDefaultGeometry())) {
                // Parse all points in the geometry, splitting into
                // individual graphhopper edges
                // whenever we find a node in the list of points
                Coordinate startTowerPnt = null;
                List<Coordinate> pillars = new ArrayList<Coordinate>();
                for (Coordinate point : points) {
                    if (startTowerPnt == null) {
                        startTowerPnt = point;
                    } else {
                        int state = coordState.get(point);
                        if (state >= FIRST_NODE_ID) {
                            int fromTowerNodeId = coordState.get(startTowerPnt);
                            int toTowerNodeId = state;
                            // get distance and estimated centres
                            double distance = getWayLength(startTowerPnt, pillars, point);
                            GHPoint estmCentre = new GHPoint(0.5 * (lat(startTowerPnt) + lat(point)), 0.5 * (lng(startTowerPnt) + lng(point)));
                            PointList pillarNodes = new PointList(pillars.size(), false);
                            for (Coordinate pillar : pillars) {
                                pillarNodes.add(lat(pillar), lng(pillar));
                            }
                            addEdge(fromTowerNodeId, toTowerNodeId, road, distance, estmCentre, pillarNodes);
                            startTowerPnt = point;
                            pillars.clear();
                        } else {
                            pillars.add(point);
                        }
                    }
                }
            }
        }
    } finally {
        if (roads != null) {
            roads.close();
        }
        if (dataStore != null) {
            dataStore.dispose();
        }
    }
}

Example 24 with SimpleFeature

use of org.opengis.feature.simple.SimpleFeature in project graphhopper by graphhopper.

the class OSMShapeFileReader method processJunctions.

@Override
void processJunctions() {
    DataStore dataStore = null;
    FeatureIterator<SimpleFeature> roads = null;
    try {
        dataStore = openShapefileDataStore(roadsFile, encoding);
        roads = getFeatureIterator(dataStore);
        HashSet<Coordinate> tmpSet = new HashSet<>();
        while (roads.hasNext()) {
            SimpleFeature road = roads.next();
            for (Coordinate[] points : getCoords(road.getDefaultGeometry())) {
                tmpSet.clear();
                for (int i = 0; i < points.length; i++) {
                    Coordinate c = points[i];
                    // duplicate coords or a road which forms a circle (e.g. roundabout)
                    if (tmpSet.contains(c))
                        continue;
                    tmpSet.add(c);
                    // skip if its already a node
                    int state = coordState.get(c);
                    if (state >= FIRST_NODE_ID) {
                        continue;
                    }
                    if (i == 0 || i == points.length - 1 || state == COORD_STATE_PILLAR) {
                        // turn into a node if its the first or last
                        // point, or already appeared in another edge
                        int nodeId = nextNodeId++;
                        coordState.put(c, nodeId);
                        saveTowerPosition(nodeId, c);
                    } else if (state == COORD_STATE_UNKNOWN) {
                        // mark it as a pillar (which may get upgraded
                        // to an edge later)
                        coordState.put(c, COORD_STATE_PILLAR);
                    }
                }
            }
        }
    } finally {
        if (roads != null) {
            roads.close();
        }
        if (dataStore != null) {
            dataStore.dispose();
        }
    }
    if (nextNodeId == FIRST_NODE_ID)
        throw new IllegalArgumentException("No data found for roads file " + roadsFile);
    LOGGER.info("Number of junction points : " + (nextNodeId - FIRST_NODE_ID));
}

Example 25 with SimpleFeature

use of org.opengis.feature.simple.SimpleFeature in project GeoGig by boundlessgeo.

the class OSMUnmapOpTest method testMappingAndUnmappingOfNodes.

@Test
public void testMappingAndUnmappingOfNodes() throws Exception {
    // Import
    String filename = OSMImportOp.class.getResource("nodes.xml").getFile();
    File file = new File(filename);
    geogig.command(OSMImportOp.class).setDataSource(file.getAbsolutePath()).call();
    geogig.command(AddOp.class).call();
    geogig.command(CommitOp.class).setMessage("msg").call();
    // Map
    Map<String, AttributeDefinition> fields = Maps.newHashMap();
    Map<String, List<String>> mappings = Maps.newHashMap();
    mappings.put("highway", Lists.newArrayList("bus_stop"));
    fields.put("geom", new AttributeDefinition("geom", FieldType.POINT));
    fields.put("name", new AttributeDefinition("name", FieldType.STRING));
    Map<String, List<String>> filterExclude = Maps.newHashMap();
    MappingRule mappingRule = new MappingRule("busstops", mappings, filterExclude, fields, null);
    List<MappingRule> mappingRules = Lists.newArrayList();
    mappingRules.add(mappingRule);
    Mapping mapping = new Mapping(mappingRules);
    geogig.command(OSMMapOp.class).setMapping(mapping).call();
    Optional<RevFeature> revFeature = geogig.command(RevObjectParse.class).setRefSpec("HEAD:busstops/507464799").call(RevFeature.class);
    assertTrue(revFeature.isPresent());
    Optional<RevFeatureType> featureType = geogig.command(ResolveFeatureType.class).setRefSpec("HEAD:busstops/507464799").call();
    assertTrue(featureType.isPresent());
    ImmutableList<Optional<Object>> values = revFeature.get().getValues();
    assertEquals(3, values.size());
    String wkt = "POINT (7.1959361 50.739397)";
    assertEquals(wkt, values.get(2).get().toString());
    assertEquals(507464799l, values.get(0).get());
    // Modify a node
    GeometryFactory gf = new GeometryFactory();
    SimpleFeatureBuilder fb = new SimpleFeatureBuilder((SimpleFeatureType) featureType.get().type());
    fb.set("geom", gf.createPoint(new Coordinate(0, 1)));
    fb.set("name", "newname");
    fb.set("id", 507464799l);
    SimpleFeature newFeature = fb.buildFeature("507464799");
    geogig.getRepository().workingTree().insert("busstops", newFeature);
    // check that it was correctly inserted in the working tree
    Optional<RevFeature> mapped = geogig.command(RevObjectParse.class).setRefSpec("WORK_HEAD:busstops/507464799").call(RevFeature.class);
    assertTrue(mapped.isPresent());
    values = mapped.get().getValues();
    assertEquals("POINT (0 1)", values.get(2).get().toString());
    assertEquals(507464799l, ((Long) values.get(0).get()).longValue());
    assertEquals("newname", values.get(1).get().toString());
    // unmap
    geogig.command(OSMUnmapOp.class).setPath("busstops").call();
    // check that the unmapped node has the changes we introduced
    Optional<RevFeature> unmapped = geogig.command(RevObjectParse.class).setRefSpec("WORK_HEAD:node/507464799").call(RevFeature.class);
    assertTrue(unmapped.isPresent());
    values = unmapped.get().getValues();
    assertEquals("POINT (0 1)", values.get(6).get().toString());
    assertEquals("bus:yes|public_transport:platform|highway:bus_stop|VRS:ortsteil:Hoholz|name:newname|VRS:ref:68566|VRS:gemeinde:BONN", values.get(3).get().toString());
    // check that unchanged nodes keep their attributes
    Optional<RevFeature> unchanged = geogig.command(RevObjectParse.class).setRefSpec("WORK_HEAD:node/1633594723").call(RevFeature.class);
    values = unchanged.get().getValues();
    assertEquals("14220478", values.get(4).get().toString());
    assertEquals("1355097351000", values.get(2).get().toString());
    assertEquals("2", values.get(1).get().toString());
}