public MapContext buildContext() { RandomStyleFactory RANDOM_STYLE_FACTORY = new RandomStyleFactory(); MapContext context = null; MapLayer layer; try { context = new DefaultMapContext(DefaultGeographicCRS.WGS84); DataStore store = DataStoreFinder.getDataStore( new SingletonMap( "url", Demo_ContextTree.class.getResource( "/org/geotools/gui/swing/demo/shape/test_polygon.shp"))); FeatureSource<SimpleFeatureType, SimpleFeature> fs = store.getFeatureSource(store.getTypeNames()[0]); Style style = RANDOM_STYLE_FACTORY.createRandomVectorStyle(fs); layer = new DefaultMapLayer(fs, style); layer.setTitle("demo_polygon.shp"); context.addLayer(layer); store = DataStoreFinder.getDataStore( new SingletonMap( "url", Demo_ContextTree.class.getResource( "/org/geotools/gui/swing/demo/shape/test_ligne.shp"))); fs = store.getFeatureSource(store.getTypeNames()[0]); style = RANDOM_STYLE_FACTORY.createRandomVectorStyle(fs); layer = new DefaultMapLayer(fs, style); layer.setTitle("demo_line.shp"); context.addLayer(layer); store = DataStoreFinder.getDataStore( new SingletonMap( "url", Demo_ContextTree.class.getResource( "/org/geotools/gui/swing/demo/shape/test_point.shp"))); fs = store.getFeatureSource(store.getTypeNames()[0]); style = RANDOM_STYLE_FACTORY.createRandomVectorStyle(fs); layer = new DefaultMapLayer(fs, style); layer.setTitle("demo_point.shp"); context.addLayer(layer); context.setTitle("DemoContext"); } catch (Exception ex) { ex.printStackTrace(); } return context; }
@Test public void testModifyIssue() throws Exception { String newDescription = "new modified description"; // $NON-NLS-1$ list.clear(); list.add(IssuesListTestHelper.createFeatureIssue("test")); // $NON-NLS-1$ list.refresh(); assertEquals(1, list.size()); IIssue issue = list.get(0); issue.setDescription(newDescription); ((IRemoteIssuesList) list).save(issue); FilterFactory factory = CommonFactoryFinder.getFilterFactory(GeoTools.getDefaultHints()); Expression expr2 = factory.literal(issue.getId()); Expression expr1 = factory.property(IssuesListTestHelper.ISSUE_ID_ATTR); Filter filter = factory.equals(expr1, expr2); SimpleFeature next = store .getFeatureSource(featureType.getName().getLocalPart()) .getFeatures(filter) .features() .next(); assertEquals(newDescription, next.getAttribute(IssuesListTestHelper.DESCRIPTION_ATTR)); }
private void save() throws Exception { FeatureStore fs = (FeatureStore) ds.getFeatureSource("poly_county"); FeatureType ft = fs.getSchema(); MemoryDataStore memorystore = new MemoryDataStore(); ArrayList polys = new ArrayList(resultPolygon); Geometry gfinal = null; if (polys.size() == 1) { gfinal = (Polygon) polys.get(0); // POLYGON } else { GeometryFactory gf = ((Polygon) polys.get(0)).getFactory(); gfinal = new MultiPolygon((Polygon[]) polys.toArray(new Polygon[polys.size()]), gf); } gfinal = gfinal.buffer(0); // for topologic problems. Object[] values = new Object[5]; values[ft.find("module")] = MODULE; values[ft.find("gen_full")] = gfinal; values[ft.find("gen_1")] = generalize(gfinal, tolerance1); ; values[ft.find("gen_2")] = generalize(gfinal, tolerance1); ; values[ft.find("gen_3")] = generalize(gfinal, tolerance1); ; Feature f = ft.create(values); memorystore.addFeature(f); fs.addFeatures(memorystore.getFeatureReader("poly_county")); }
@SuppressWarnings({"rawtypes", "unchecked"}) private FeatureSource getFeatureSource(String typeName) { FeatureSource featureSource; try { featureSource = dataStore.getFeatureSource(typeName); } catch (Exception e) { throw new GeoToolsOpException(StatusCode.UNABLE_TO_GET_FEATURES); } return new ForwardingFeatureSource(featureSource) { @Override public FeatureCollection getFeatures(Query query) throws IOException { final FeatureCollection features = super.getFeatures(query); return new ForwardingFeatureCollection(features) { @Override public FeatureIterator features() { final FeatureType featureType = getSchema(); final String fidPrefix = featureType.getName().getLocalPart() + "."; FeatureIterator iterator = delegate.features(); return new FidPrefixRemovingIterator(iterator, fidPrefix); } }; } }; }
/** * Creates the source datastore reader. * * @param sourceDataStore * @param transaction * @param query * @return * @throws IOException */ protected FeatureStore<SimpleFeatureType, SimpleFeature> createSourceReader( DataStore sourceDataStore, final Transaction transaction, Query query) throws IOException { FeatureStore<SimpleFeatureType, SimpleFeature> featureReader = (FeatureStore<SimpleFeatureType, SimpleFeature>) sourceDataStore.getFeatureSource(query.getTypeName()); featureReader.setTransaction(transaction); return featureReader; }
@SuppressWarnings("unchecked") private SimpleFeatureSource getFeatureSource(final URL shpfile) throws IOException { Map params = new HashMap<String, String>(); params.put(ShapefileDataStoreFactory.CREATE_SPATIAL_INDEX.key, "false"); params.put(ShapefileDataStoreFactory.URLP.key, shpfile); DataStore ds = DataStoreFinder.getDataStore(params); return ds.getFeatureSource(ds.getTypeNames()[0]); }
@Override protected void setUpInternal(SystemTestData data) throws Exception { // run all the tests against a store that can do native paging (h2) and one that // can't (property) Catalog cat = getCatalog(); DataStoreInfo ds = cat.getFactory().createDataStore(); ds.setName("foo"); ds.setWorkspace(cat.getDefaultWorkspace()); Map params = ds.getConnectionParameters(); params.put("dbtype", "h2"); params.put("database", getTestData().getDataDirectoryRoot().getAbsolutePath()); cat.add(ds); FeatureSource fs1 = getFeatureSource(SystemTestData.FIFTEEN); FeatureSource fs2 = getFeatureSource(SystemTestData.SEVEN); DataStore store = (DataStore) ds.getDataStore(null); SimpleFeatureTypeBuilder tb = new SimpleFeatureTypeBuilder(); tb.init((SimpleFeatureType) fs1.getSchema()); tb.add("num", Integer.class); tb.remove("boundedBy"); store.createSchema(tb.buildFeatureType()); tb.init((SimpleFeatureType) fs2.getSchema()); tb.add("num", Integer.class); tb.remove("boundedBy"); store.createSchema(tb.buildFeatureType()); CatalogBuilder cb = new CatalogBuilder(cat); cb.setStore(ds); FeatureStore fs = (FeatureStore) store.getFeatureSource("Fifteen"); addFeatures(fs, fs1.getFeatures()); FeatureTypeInfo ft = cb.buildFeatureType(fs); cat.add(ft); fs = (FeatureStore) store.getFeatureSource("Seven"); addFeatures(fs, fs2.getFeatures()); ft = cb.buildFeatureType(fs); cat.add(ft); }
@Test public void testInitialLoad() throws Exception { assertEquals(4, list.size()); assertEquals("0", list.get(0).getId()); // $NON-NLS-1$ assertEquals("1", list.get(1).getId()); // $NON-NLS-1$ assertEquals("2", list.get(2).getId()); // $NON-NLS-1$ assertEquals("3", list.get(3).getId()); // $NON-NLS-1$ assertEquals( 4, store.getFeatureSource(featureType.getName().getLocalPart()).getCount(Query.ALL)); }
@Test public void testRemoveInt() throws Exception { list.remove(1); assertEquals(3, list.size()); assertEquals("0", list.get(0).getId()); // $NON-NLS-1$ assertEquals("2", list.get(1).getId()); // $NON-NLS-1$ assertEquals("3", list.get(2).getId()); // $NON-NLS-1$ assertEquals( 3, store.getFeatureSource(featureType.getName().getLocalPart()).getCount(Query.ALL)); }
private SimpleFeatureSource getLatLonFeatureSource() { try { DataStore ds = LATLON == null ? null : LATLON.get(); if (ds == null) { ds = createLatLonDataStore(); LATLON = new WeakReference<DataStore>(ds); } return ds.getFeatureSource("latlon"); } catch (Exception e) { throw new RuntimeException(e); } }
@Test public void testAddIIssue() throws Exception { FeatureIssue issue = IssuesListTestHelper.createFeatureIssue("new"); // $NON-NLS-1$ list.add(issue); assertEquals(5, list.size()); assertEquals("new", list.get(4).getId()); // $NON-NLS-1$ list.refresh(); assertEquals(5, list.size()); assertEquals("new", list.get(4).getId()); // $NON-NLS-1$ assertEquals("groupID", list.get(4).getGroupId()); // $NON-NLS-1$ assertEquals("test description", list.get(4).getDescription()); // $NON-NLS-1$ assertEquals( 5, store.getFeatureSource(featureType.getName().getLocalPart()).getCount(Query.ALL)); }
@Test @Ignore // this test is skipped, it checks something that formally is what we should expect, // but for the moment this breaks big time the shapefile renderer optimizations // until we get rid of the latter let's be a little lax on this one... public void testFeatureSource() throws Exception { File file = copyShapefiles("shapes/archsites.shp"); tempDir = file.getParentFile(); DataStore dds = new DirectoryDataStore(tempDir, getFileStoreFactory()); FeatureSource fs = dds.getFeatureSource("archsites"); assertNotNull(fs); assertSame(dds, fs.getDataStore()); dds.dispose(); }
public void update(Object updatedObject) { if (updatedObject instanceof List) { String text = null; List layers = (List) updatedObject; for (Object layer : layers) { if (layer instanceof JGrassMapGeoResource) { JGrassMapGeoResource rasterMapResource = (JGrassMapGeoResource) layer; try { text = rasterMapResource.getInfo(null).getName(); JGrassRegion fileWindow = rasterMapResource.getFileWindow(); if (fileWindow != null) { setWidgetsToWindow(fileWindow); } } catch (IOException e1) { return; } } else if (layer instanceof DataStore || layer instanceof UDIGFeatureStore) { try { DataStore store = ((DataStore) layer); FeatureSource featureStore = store.getFeatureSource(store.getTypeNames()[0]); Envelope envelope = featureStore.getBounds(); ActiveRegionStyle style = getActiveRegionStyle(); JGrassRegion activeWindow = new JGrassRegion( style.west, style.east, style.south, style.north, style.rows, style.cols); JGrassRegion newWindow = JGrassRegion.adaptActiveRegionToEnvelope(envelope, activeWindow); northText.setText(String.valueOf(newWindow.getNorth())); southText.setText(String.valueOf(newWindow.getSouth())); eastText.setText(String.valueOf(newWindow.getEast())); westText.setText(String.valueOf(newWindow.getWest())); textModified(bound_type); } catch (IOException e1) { e1.printStackTrace(); return; } } else { return; } } if (text == null) { return; } } }
@Test public void testFeatureReaderWithFilterBBoxPOST() throws NoSuchElementException, IllegalAttributeException, IOException, SAXException, IllegalFilterException { if (url == null) return; Map m = new HashMap(); m.put(WFSDataStoreFactory.URL.key, url); m.put(WFSDataStoreFactory.TIMEOUT.key, new Integer(100000)); DataStore post = (WFS_1_0_0_DataStore) (new WFSDataStoreFactory()).createDataStore(m); String typeName = post.getTypeNames()[0]; Envelope bbox = post.getFeatureSource(typeName).getBounds(); WFSDataStoreReadTest.doFeatureReaderWithBBox(url, true, false, 0, bbox); }
@Override public <T> T resolve(Class<T> adaptee, IProgressMonitor monitor) throws IOException { if (null == adaptee) { return null; } if (adaptee.isAssignableFrom(FeatureSource.class)) { DataStore ds = this.service.resolve(DataStore.class, monitor); String[] a = ds.getTypeNames(); String featureName = a[0]; FeatureSource<SimpleFeatureType, SimpleFeature> fs = ds.getFeatureSource(featureName); return adaptee.cast(fs); } return super.resolve(adaptee, monitor); }
@Test public void testBackendRemovedIssue() throws Exception { FeatureStore<SimpleFeatureType, SimpleFeature> fs = (FeatureStore<SimpleFeatureType, SimpleFeature>) store.getFeatureSource(featureType.getName().getLocalPart()); FilterFactory factory = CommonFactoryFinder.getFilterFactory(GeoTools.getDefaultHints()); Expression expr2 = factory.literal("1"); Expression expr1 = factory.property(IssuesListTestHelper.ISSUE_ID_ATTR); Filter filter = factory.equals(expr1, expr2); fs.removeFeatures(filter); list.refresh(); for (IIssue issue : list) { System.out.println(issue.getId()); } assertEquals(3, list.size()); assertEquals("0", list.get(0).getId()); // $NON-NLS-1$ assertEquals("2", list.get(1).getId()); // $NON-NLS-1$ assertEquals("3", list.get(2).getId()); // $NON-NLS-1$ }
/** * This test is made with mock objects because the property data store does not generate fids in * the <type>.<id> form */ @SuppressWarnings("unchecked") @Test public void testAppend() throws Exception { SimpleFeatureType type = DataUtilities.createType("trees", "the_geom:Point,FID:String,NAME:String"); SimpleFeatureStore fs = createMock(SimpleFeatureStore.class); expect(fs.addFeatures(isA(FeatureCollection.class))) .andReturn(Collections.singletonList((FeatureId) (new FeatureIdImpl("trees.105")))); replay(fs); DataStore ds = createMock(DataStore.class); expect(ds.getTypeNames()).andReturn(new String[] {"trees"}).anyTimes(); expect(ds.getSchema("trees")).andReturn(type).anyTimes(); expect(ds.getFeatureSource("trees")).andReturn(fs); replay(ds); RetypingDataStore rts = new RetypingDataStore(ds) { @Override protected String transformFeatureTypeName(String originalName) { return "oaks"; } }; 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); SimpleFeatureStore store = (SimpleFeatureStore) rts.getFeatureSource("oaks"); List<FeatureId> ids = store.addFeatures(fc); assertEquals(1, ids.size()); String id = ((FeatureId) ids.iterator().next()).getID(); assertTrue("Id does not start with " + "oaks" + " it's " + id, id.startsWith("oaks")); }
/** * Builds a FeatureStore for the output Feature. * * @param store * @param schema * @return * @throws IOException */ protected FeatureStore<SimpleFeatureType, SimpleFeature> createOutputWriter( DataStore store, SimpleFeatureType schema, Transaction transaction) throws IOException { String destTypeName = schema.getTypeName(); boolean createSchema = true; for (String typeName : store.getTypeNames()) { if (typeName.equalsIgnoreCase(destTypeName)) { createSchema = false; destTypeName = typeName; } } // check for case changing in typeName if (createSchema) { store.createSchema(schema); for (String typeName : store.getTypeNames()) { if (!typeName.equals(destTypeName) && typeName.equalsIgnoreCase(destTypeName)) { destTypeName = typeName; } } } FeatureStore<SimpleFeatureType, SimpleFeature> result = (FeatureStore<SimpleFeatureType, SimpleFeature>) store.getFeatureSource(destTypeName); result.setTransaction(transaction); return result; }
/** * Writing test that only engages against a remote geoserver. * * <p>Makes reference to the standard featureTypes that geoserver ships with. NOTE: Ignoring this * test for now because it edits topp:states and GeoServer doesn't return the correct Feature IDs * on transactions against shapefiles */ @Test @Ignore public void testWrite() throws NoSuchElementException, IllegalFilterException, IOException, IllegalAttributeException { if (url == null) return; Map m = new HashMap(); m.put(WFSDataStoreFactory.URL.key, url); m.put(WFSDataStoreFactory.TIMEOUT.key, new Integer(10000000)); DataStore post = (WFS_1_0_0_DataStore) (new WFSDataStoreFactory()).createDataStore(m); String typename = TO_EDIT_TYPE; SimpleFeatureType ft = post.getSchema(typename); SimpleFeatureSource fs = post.getFeatureSource(typename); class Watcher implements FeatureListener { public int count = 0; public void changed(FeatureEvent featureEvent) { System.out.println("Event " + featureEvent); count++; } } Watcher watcher = new Watcher(); fs.addFeatureListener(watcher); Id startingFeatures = createFidFilter(fs); FilterFactory2 filterFac = CommonFactoryFinder.getFilterFactory2(GeoTools.getDefaultHints()); try { GeometryFactory gf = new GeometryFactory(); MultiPolygon mp = gf.createMultiPolygon( new Polygon[] { gf.createPolygon( gf.createLinearRing( new Coordinate[] { new Coordinate(-88.071564, 37.51099), new Coordinate(-88.467644, 37.400757), new Coordinate(-90.638329, 42.509361), new Coordinate(-89.834618, 42.50346), new Coordinate(-88.071564, 37.51099) }), new LinearRing[] {}) }); mp.setUserData("http://www.opengis.net/gml/srs/epsg.xml#" + EPSG_CODE); PropertyName geometryAttributeExpression = filterFac.property(ft.getGeometryDescriptor().getLocalName()); PropertyIsNull geomNullCheck = filterFac.isNull(geometryAttributeExpression); Query query = new Query(typename, filterFac.not(geomNullCheck), 1, Query.ALL_NAMES, null); SimpleFeatureIterator inStore = fs.getFeatures(query).features(); SimpleFeature f, f2; try { SimpleFeature feature = inStore.next(); SimpleFeature copy = SimpleFeatureBuilder.deep(feature); SimpleFeature copy2 = SimpleFeatureBuilder.deep(feature); f = SimpleFeatureBuilder.build(ft, copy.getAttributes(), null); f2 = SimpleFeatureBuilder.build(ft, copy2.getAttributes(), null); assertFalse("Max Feature failed", inStore.hasNext()); } finally { inStore.close(); } org.geotools.util.logging.Logging.getLogger("org.geotools.data.wfs").setLevel(Level.FINE); SimpleFeatureCollection inserts = DataUtilities.collection(new SimpleFeature[] {f, f2}); Id fp = WFSDataStoreWriteOnlineTest.doInsert(post, ft, inserts); // / okay now count ... FeatureReader<SimpleFeatureType, SimpleFeature> count = post.getFeatureReader(new Query(ft.getTypeName()), Transaction.AUTO_COMMIT); int i = 0; while (count.hasNext() && i < 3) { f = count.next(); i++; } count.close(); WFSDataStoreWriteOnlineTest.doDelete(post, ft, fp); WFSDataStoreWriteOnlineTest.doUpdate(post, ft, ATTRIBUTE_TO_EDIT, NEW_EDIT_VALUE); // assertFalse("events not fired", watcher.count == 0); } finally { try { ((SimpleFeatureStore) fs).removeFeatures(filterFac.not(startingFeatures)); } catch (Exception e) { System.out.println(e); } } }
private SimpleFeatureIterator getIterator() throws Exception { String typeName = dataStore.getTypeNames()[0]; SimpleFeatureCollection collection = dataStore.getFeatureSource(typeName).getFeatures(); return collection.features(); }
public static IGlobeFeatureCollection< IVector2, ? extends IBoundedGeometry2D<? extends IFinite2DBounds<?>>> readFeatures(final DataStore dataStore, final String layerName, final GProjection projection) throws Exception { final SimpleFeatureSource featureSource = dataStore.getFeatureSource(layerName); final SimpleFeatureCollection featuresCollection = featureSource.getFeatures(); final GIntHolder validCounter = new GIntHolder(0); // final GIntHolder polygonsWithHolesCounter = new GIntHolder(0); final GIntHolder invalidCounter = new GIntHolder(0); // final GIntHolder validVerticesCounter = new GIntHolder(0); final GIntHolder polygonsCounter = new GIntHolder(0); final GIntHolder linesCounter = new GIntHolder(0); final GIntHolder pointsCounter = new GIntHolder(0); final int featuresCount = featuresCollection.size(); final ArrayList<IGlobeFeature<IVector2, IBoundedGeometry2D<? extends IFinite2DBounds<?>>>> euclidFeatures = new ArrayList< IGlobeFeature<IVector2, IBoundedGeometry2D<? extends IFinite2DBounds<?>>>>( featuresCount); final GProgress progress = new GProgress(featuresCount) { @Override public void informProgress( final double percent, final long elapsed, final long estimatedMsToFinish) { // System.out.println("Loading \"" + fileName.buildPath() + "\" " // + progressString(percent, elapsed, // estimatedMsToFinish)); System.out.println( "Loading data from data storage: " + layerName + " " + progressString(percent, elapsed, estimatedMsToFinish)); } }; final FeatureIterator<SimpleFeature> iterator = featuresCollection.features(); while (iterator.hasNext()) { final SimpleFeature feature = iterator.next(); final GeometryAttribute geometryAttribute = feature.getDefaultGeometryProperty(); final GeometryType type = geometryAttribute.getType(); if (type.getBinding() == com.vividsolutions.jts.geom.MultiPolygon.class) { polygonsCounter.increment(); final com.vividsolutions.jts.geom.MultiPolygon multipolygon = (com.vividsolutions.jts.geom.MultiPolygon) geometryAttribute.getValue(); final int geometriesCount = multipolygon.getNumGeometries(); final List<IPolygon2D> polygons = new ArrayList<IPolygon2D>(geometriesCount); for (int i = 0; i < geometriesCount; i++) { final com.vividsolutions.jts.geom.Polygon jtsPolygon = (com.vividsolutions.jts.geom.Polygon) multipolygon.getGeometryN(i); try { final IPolygon2D euclidPolygon = createEuclidPolygon(projection, jtsPolygon); if (euclidPolygon != null) { // euclidFeatures.add(createFeature(euclidPolygon, feature)); polygons.add(euclidPolygon); validCounter.increment(); } } catch (final IllegalArgumentException e) { // System.err.println(e.getMessage()); } } if (!polygons.isEmpty()) { if (polygons.size() == 1) { euclidFeatures.add(createFeature(polygons.get(0), feature)); } else { euclidFeatures.add(createFeature(new GMultiGeometry2D<IPolygon2D>(polygons), feature)); } } } else if (type.getBinding() == com.vividsolutions.jts.geom.MultiLineString.class) { linesCounter.increment(); final com.vividsolutions.jts.geom.MultiLineString multiline = (com.vividsolutions.jts.geom.MultiLineString) geometryAttribute.getValue(); final int geometriesCount = multiline.getNumGeometries(); final List<IPolygonalChain2D> lines = new ArrayList<IPolygonalChain2D>(geometriesCount); for (int i = 0; i < geometriesCount; i++) { final com.vividsolutions.jts.geom.LineString jtsLine = (com.vividsolutions.jts.geom.LineString) multiline.getGeometryN(i); try { final IPolygonalChain2D euclidLine = createLine(jtsLine.getCoordinates(), projection); // euclidFeatures.add(createFeature(euclidLines, feature)); lines.add(euclidLine); } catch (final IllegalArgumentException e) { // System.err.println(e.getMessage()); } } if (!lines.isEmpty()) { if (lines.size() == 1) { euclidFeatures.add(createFeature(lines.get(0), feature)); } else { euclidFeatures.add( createFeature(new GMultiGeometry2D<IPolygonalChain2D>(lines), feature)); } } validCounter.increment(); } else if (type.getBinding() == com.vividsolutions.jts.geom.Point.class) { pointsCounter.increment(); final IVector2 euclidPoint = createPoint( ((com.vividsolutions.jts.geom.Point) geometryAttribute.getValue()).getCoordinate(), projection); euclidFeatures.add(createFeature(euclidPoint, feature)); validCounter.increment(); } else if (type.getBinding() == com.vividsolutions.jts.geom.MultiPoint.class) { final IBoundedGeometry2D<? extends IFinite2DBounds<?>> euclidMultipoint = createEuclidMultiPoint(geometryAttribute, projection); euclidFeatures.add(createFeature(euclidMultipoint, feature)); validCounter.increment(); } else { invalidCounter.increment(); System.out.println("invalid type: " + type); } progress.stepDone(); } dataStore.dispose(); euclidFeatures.trimToSize(); System.out.println(); System.out.println("Features: " + featuresCount); System.out.println(); System.out.println("Read " + validCounter.get() + " valid geometries"); System.out.println(" => " + polygonsCounter.get() + " valid polygons"); System.out.println(" => " + linesCounter.get() + " valid lines"); System.out.println(" => " + pointsCounter.get() + " valid points"); System.out.println(); if (invalidCounter.get() > 0) { System.out.println("Ignored " + invalidCounter.get() + " invalid geometries"); } System.out.println(); final SimpleFeatureType schema = featureSource.getSchema(); final int fieldsCount = schema.getAttributeCount(); final List<GField> fields = new ArrayList<GField>(fieldsCount); System.out.println("Fields count: " + fieldsCount); for (int i = 0; i < fieldsCount; i++) { final String fieldName = schema.getType(i).getName().getLocalPart(); System.out.println("Fieldname: " + fieldName); final Class<?> fieldType = schema.getType(i).getBinding(); fields.add(new GField(fieldName, fieldType)); } return new GListFeatureCollection<IVector2, IBoundedGeometry2D<? extends IFinite2DBounds<?>>>( GProjection.EPSG_4326, fields, euclidFeatures, "uniqueId_000"); }
private SimpleFeatureType importDataIntoStore( SimpleFeatureCollection features, String name, DataStoreInfo storeInfo) throws IOException, ProcessException { SimpleFeatureType targetType; // grab the data store DataStore ds = (DataStore) storeInfo.getDataStore(null); // decide on the target ft name SimpleFeatureType sourceType = features.getSchema(); if (name != null) { SimpleFeatureTypeBuilder tb = new SimpleFeatureTypeBuilder(); tb.init(sourceType); tb.setName(name); sourceType = tb.buildFeatureType(); } // create the schema ds.createSchema(sourceType); // try to get the target feature type (might have slightly different // name and structure) targetType = ds.getSchema(sourceType.getTypeName()); if (targetType == null) { // ouch, the name was changed... we can only guess now... // try with the typical Oracle mangling targetType = ds.getSchema(sourceType.getTypeName().toUpperCase()); } if (targetType == null) { throw new WPSException( "The target schema was created, but with a name " + "that we cannot relate to the one we provided the data store. Cannot proceeed further"); } else { // check the layer is not already there String newLayerName = storeInfo.getWorkspace().getName() + ":" + targetType.getTypeName(); LayerInfo layer = catalog.getLayerByName(newLayerName); // todo: we should not really reach here and know beforehand what the targetType // name is, but if we do we should at least get a way to drop it if (layer != null) { throw new ProcessException( "Target layer " + newLayerName + " already exists in the catalog"); } } // try to establish a mapping with old and new attributes. This is again // just guesswork until we have a geotools api that will give us the // exact mapping to be performed Map<String, String> mapping = buildAttributeMapping(sourceType, targetType); // start a transaction and fill the target with the input features Transaction t = new DefaultTransaction(); SimpleFeatureStore fstore = (SimpleFeatureStore) ds.getFeatureSource(targetType.getTypeName()); fstore.setTransaction(t); SimpleFeatureIterator fi = features.features(); SimpleFeatureBuilder fb = new SimpleFeatureBuilder(targetType); while (fi.hasNext()) { SimpleFeature source = fi.next(); fb.reset(); for (String sname : mapping.keySet()) { fb.set(mapping.get(sname), source.getAttribute(sname)); } SimpleFeature target = fb.buildFeature(null); fstore.addFeatures(DataUtilities.collection(target)); } t.commit(); t.close(); return targetType; }
/** Executes the export command using the provided options. */ @Override protected final void runInternal(GeogigCLI cli) throws IOException { if (args.isEmpty()) { printUsage(cli); throw new CommandFailedException(); } String path = args.get(0); String tableName = args.get(1); checkParameter(tableName != null && !tableName.isEmpty(), "No table name specified"); DataStore dataStore = getDataStore(); ObjectId featureTypeId = null; if (!Arrays.asList(dataStore.getTypeNames()).contains(tableName)) { SimpleFeatureType outputFeatureType; if (sFeatureTypeId != null) { // Check the feature type id string is a correct id Optional<ObjectId> id = cli.getGeogig().command(RevParse.class).setRefSpec(sFeatureTypeId).call(); checkParameter(id.isPresent(), "Invalid feature type reference", sFeatureTypeId); TYPE type = cli.getGeogig().command(ResolveObjectType.class).setObjectId(id.get()).call(); checkParameter( type.equals(TYPE.FEATURETYPE), "Provided reference does not resolve to a feature type: ", sFeatureTypeId); outputFeatureType = (SimpleFeatureType) cli.getGeogig() .command(RevObjectParse.class) .setObjectId(id.get()) .call(RevFeatureType.class) .get() .type(); featureTypeId = id.get(); } else { try { SimpleFeatureType sft = getFeatureType(path, cli); outputFeatureType = new SimpleFeatureTypeImpl( new NameImpl(tableName), sft.getAttributeDescriptors(), sft.getGeometryDescriptor(), sft.isAbstract(), sft.getRestrictions(), sft.getSuper(), sft.getDescription()); } catch (GeoToolsOpException e) { throw new CommandFailedException("No features to export.", e); } } try { dataStore.createSchema(outputFeatureType); } catch (IOException e) { throw new CommandFailedException("Cannot create new table in database", e); } } else { if (!overwrite) { throw new CommandFailedException("The selected table already exists. Use -o to overwrite"); } } SimpleFeatureSource featureSource = dataStore.getFeatureSource(tableName); if (!(featureSource instanceof SimpleFeatureStore)) { throw new CommandFailedException("Can't write to the selected table"); } SimpleFeatureStore featureStore = (SimpleFeatureStore) featureSource; if (overwrite) { try { featureStore.removeFeatures(Filter.INCLUDE); } catch (IOException e) { throw new CommandFailedException("Error truncating table: " + e.getMessage(), e); } } ExportOp op = cli.getGeogig() .command(ExportOp.class) .setFeatureStore(featureStore) .setPath(path) .setFilterFeatureTypeId(featureTypeId) .setAlter(alter); if (defaultType) { op.exportDefaultFeatureType(); } try { op.setProgressListener(cli.getProgressListener()).call(); } catch (IllegalArgumentException iae) { throw new org.locationtech.geogig.cli.InvalidParameterException(iae.getMessage(), iae); } catch (GeoToolsOpException e) { switch (e.statusCode) { case MIXED_FEATURE_TYPES: throw new CommandFailedException( "The selected tree contains mixed feature types. Use --defaulttype or --featuretype <feature_type_ref> to export.", e); default: throw new CommandFailedException("Could not export. Error:" + e.statusCode.name(), e); } } cli.getConsole().println(path + " exported successfully to " + tableName); }
/** * Extract the data as defined in the request object. * * @return the directory that contains the extracted file */ public File extract(ExtractorLayerRequest request) throws IOException, TransformException, FactoryException { if (request._owsType != OWSType.WFS) { throw new IllegalArgumentException(request._owsType + "must be WFS for the WfsExtractor"); } Map<String, Serializable> params = new HashMap<String, Serializable>(); params.put(WFSDataStoreFactory.URL.key, request.capabilitiesURL("WFS", "1.0.0")); params.put(WFSDataStoreFactory.LENIENT.key, true); params.put(WFSDataStoreFactory.PROTOCOL.key, true); params.put(WFSDataStoreFactory.TIMEOUT.key, Integer.valueOf(60000)); params.put(WFSDataStoreFactory.MAXFEATURES.key, Integer.valueOf(0)); // HACK I want unrestricted access to layers. // Security check takes place in ExtractorThread if (_secureHost.equalsIgnoreCase(request._url.getHost()) || "127.0.0.1".equalsIgnoreCase(request._url.getHost()) || "localhost".equalsIgnoreCase(request._url.getHost())) { LOG.debug( "WfsExtractor.extract - Secured Server: Adding extractionUserName to connection params"); if (_adminUsername != null) params.put(WFSDataStoreFactory.USERNAME.key, _adminUsername); if (_adminPassword != null) params.put(WFSDataStoreFactory.PASSWORD.key, _adminPassword); } else { LOG.debug("WfsExtractor.extract - Non Secured Server"); } DataStore sourceDs = DataStoreFinder.getDataStore(params); // WFS-ng: we need to convert the schema name String typeName = request.getWFSName(); SimpleFeatureType sourceSchema = null; // prefixed typeName if (typeName.contains(":")) { typeName = typeName.replaceFirst(":", "_"); sourceSchema = sourceDs.getSchema(typeName); } // Not prefixed one (mapserver ?) else { // Recreating the datastore forcing wfs 1.1.0, so that (presuming // the remote server is actually powered by MapServer), we would // have a typename prefixed with the same convention as before. params.put(WFSDataStoreFactory.URL.key, request.capabilitiesURL("WFS", "1.1.0")); // params.put(WFSDataStoreFactory.WFS_STRATEGY.key, "mapserver"); sourceDs = DataStoreFinder.getDataStore(params); String[] typeNames = sourceDs.getTypeNames(); for (String s : typeNames) { if (s.contains(typeName)) { typeName = s; sourceSchema = sourceDs.getSchema(s); // replace the expected typename in the request break; } } if (sourceSchema == null) { throw new IOException("Unable to find the remote layer " + typeName); } } Query query = createQuery(request, sourceSchema); SimpleFeatureCollection features = sourceDs.getFeatureSource(typeName).getFeatures(query); ProgressListener progressListener = new NullProgressListener() { @Override public void exceptionOccurred(Throwable exception) { throw new RuntimeException(exception); } }; File basedir = request.createContainingDir(_basedir); basedir.mkdirs(); FeatureWriterStrategy featuresWriter; BBoxWriter bboxWriter; LOG.debug("Number of features returned : " + features.size()); if ("shp".equalsIgnoreCase(request._format)) { featuresWriter = new ShpFeatureWriter(progressListener, sourceSchema, basedir, features); bboxWriter = new BBoxWriter( request._bbox, basedir, OGRFeatureWriter.FileFormat.shp, request._projection, progressListener); } else if ("mif".equalsIgnoreCase(request._format)) { // featuresWriter = new MifFeatureWriter(progressListener, sourceSchema, basedir, features); featuresWriter = new OGRFeatureWriter( progressListener, sourceSchema, basedir, OGRFeatureWriter.FileFormat.mif, features); bboxWriter = new BBoxWriter( request._bbox, basedir, OGRFeatureWriter.FileFormat.mif, request._projection, progressListener); } else if ("tab".equalsIgnoreCase(request._format)) { featuresWriter = new OGRFeatureWriter( progressListener, sourceSchema, basedir, OGRFeatureWriter.FileFormat.tab, features); bboxWriter = new BBoxWriter( request._bbox, basedir, OGRFeatureWriter.FileFormat.tab, request._projection, progressListener); } else if ("kml".equalsIgnoreCase(request._format)) { featuresWriter = new OGRFeatureWriter( progressListener, sourceSchema, basedir, OGRFeatureWriter.FileFormat.kml, features); bboxWriter = new BBoxWriter( request._bbox, basedir, OGRFeatureWriter.FileFormat.kml, request._projection, progressListener); } else { throw new IllegalArgumentException(request._format + " is not a recognized vector format"); } // generates the feature files and bbox file featuresWriter.generateFiles(); bboxWriter.generateFiles(); return basedir; }