@Test public void testAttributeReaderIndexed() throws IOException { URL u = TestData.url(TestCaseSupport.class, SHPFILE); File shpFile = DataUtilities.urlToFile(u); // open the test shapefile // creates both indexed and regular shapefile data store ShapefileDataStore indexedstore = new ShapefileDataStore(shpFile.toURI().toURL()); // get a random feature id from one of the stores SimpleFeatureIterator it = indexedstore.getFeatureSource().getFeatures().features(); FeatureId fid = it.next().getIdentifier(); it.close(); // query the datastore FilterFactory ff = CommonFactoryFinder.getFilterFactory(null); Filter idFilter = ff.id(Collections.singleton(fid)); final Query query = new Query( indexedstore.getSchema().getName().getLocalPart(), idFilter, new String[] {testColumn}); final SimpleFeatureCollection indexedfeatures = indexedstore.getFeatureSource().getFeatures(query); // compare the results SimpleFeatureIterator indexIterator = indexedfeatures.features(); SimpleFeature indexedFeature = indexIterator.next(); indexIterator.close(); // get the value of the duplicate column & compare it against expectation assertEquals(expectedValue, indexedFeature.getAttribute(testColumn)); // cleanup indexedstore.dispose(); }
private LineSegment extractShorelineInterect(SimpleFeature feature) { Object sceObject = ((Double) feature.getAttribute(Constants.SCE_ATTR)); Object nsdObject = feature.getAttribute(Constants.NSD_ATTR); Geometry geometry = (Geometry) feature.getDefaultGeometry(); Coordinate[] coordinates = geometry.getCoordinates(); LineSegment segment = new LineSegment(coordinates[0], coordinates[1]); double length = segment.getLength(); double sce = sceObject instanceof Number ? ((Number) sceObject).doubleValue() : Double.NaN; double nsd = nsdObject instanceof Number ? ((Number) nsdObject).doubleValue() : Double.NaN; if (sce == sce && nsd == nsd) { return extractShorelineInterectAndCheckLength(segment, nsd, sce); } else { if (sce != sce && nsd != nsd) { return extractShorelineInterectAndCheckLength(segment, 0, length); } if (sce != sce) { sce = length - nsd; } else /* if nsd != nsd */ { nsd = length - sce; } return extractShorelineInterectAndCheckLength(segment, nsd, sce); } }
public void addBuildings(final String buildingShapeFileName) { final GeometryFactory geometryFactory = new GeometryFactory(); final WKTReader wktReader = new WKTReader(geometryFactory); final ShapeFileReader shapeFileReader = new ShapeFileReader(); shapeFileReader.readFileAndInitialize(buildingShapeFileName); final Collection<SimpleFeature> features = shapeFileReader.getFeatureSet(); for (SimpleFeature ft : features) { try { final Geometry geometry = wktReader.read((ft.getAttribute("the_geom")).toString()); final String buildingType = ft.getAttribute("ANDAMAL_1T").toString(); final int buildingSize = Integer.valueOf(ft.getAttribute("AREA").toString()); final Building building = new Building(geometry, buildingSize); building.setBuildingType(buildingType); for (Zone zone : this.id2zone.values()) { if (zone.getGeometry() != null && zone.getGeometry().intersects(geometry)) { zone.addBuilding(building); break; } } } catch (ParseException e) { throw new RuntimeException(e); } } }
/** * Extract the coordinate of a FeatureCollection in a HashMap with an ID as a key. * * @param nStaz * @param collection * @throws Exception if a fiel of elevation isn't the same of the collection */ private LinkedHashMap<Integer, Coordinate> getCoordinate( int nStaz, SimpleFeatureCollection collection, String idField) throws Exception { LinkedHashMap<Integer, Coordinate> id2CoordinatesMap = new LinkedHashMap<Integer, Coordinate>(); FeatureIterator<SimpleFeature> iterator = collection.features(); Coordinate coordinate = null; try { while (iterator.hasNext()) { SimpleFeature feature = iterator.next(); int name = ((Number) feature.getAttribute(idField)).intValue(); coordinate = ((Geometry) feature.getDefaultGeometry()).getCentroid().getCoordinate(); double z = 0; if (fPointZ != null) { try { z = ((Number) feature.getAttribute(fPointZ)).doubleValue(); } catch (NullPointerException e) { pm.errorMessage(msg.message("kriging.noPointZ")); throw new Exception(msg.message("kriging.noPointZ")); } } coordinate.z = z; id2CoordinatesMap.put(name, coordinate); } } finally { iterator.close(); } return id2CoordinatesMap; }
/** * Check that a result set contains a stacked point in the right cell with expected attribute * values. Because it's not known in advance what the actual location of a stacked point will be, * a nearest-point strategy is used. * * @param result * @param coordinate * @param i * @param j */ private void checkResultPoint( SimpleFeatureCollection result, Coordinate testPt, int expectedCount, int expectedCountUnique, Double expectedProportion, Double expectedProportionUnique) { SimpleFeature f = getResultPoint(result, testPt); assertNotNull(f); /** Find closest point to loc pt, then check that the attributes match */ int count = (Integer) f.getAttribute(PointStackerProcess.ATTR_COUNT); int countunique = (Integer) f.getAttribute(PointStackerProcess.ATTR_COUNT_UNIQUE); double normCount = Double.NaN; double normCountUnique = Double.NaN; if (expectedProportion != null) { normCount = (Double) f.getAttribute(PointStackerProcess.ATTR_NORM_COUNT); normCountUnique = (Double) f.getAttribute(PointStackerProcess.ATTR_NORM_COUNT_UNIQUE); } assertEquals(expectedCount, count); assertEquals(expectedCountUnique, countunique); if (expectedProportion != null) assertEquals(expectedProportion, normCount, 0.0001); if (expectedProportionUnique != null) assertEquals(expectedProportionUnique, normCountUnique, 0.0001); }
public void testConnectionFailure() throws Exception { // create mock objects that will simulate a connection failure GSSClient client = createMock(GSSClient.class); expect(client.getCentralRevision((QName) anyObject())) .andThrow(new IOException("Host unreachable")); replay(client); GSSClientFactory factory = createMock(GSSClientFactory.class); expect(factory.createClient(new URL("http://localhost:8081/geoserver/ows"), null, null)) .andReturn(client); replay(factory); synch.clientFactory = factory; // perform synch Date start = new Date(); synch.synchronizeOustandlingLayers(); Date end = new Date(); // check we stored the last failure marker SimpleFeature f = getSingleFeature(fsUnitTables, ff.equal(ff.property("table_id"), ff.literal(1), false)); Date lastFailure = (Date) f.getAttribute("last_failure"); assertNotNull(lastFailure); assertTrue(lastFailure.compareTo(start) >= 0 && lastFailure.compareTo(end) <= 0); // check we marked the unit as failed f = getSingleFeature(fsUnits, ff.equal(ff.property("unit_name"), ff.literal("unit1"), false)); assertTrue((Boolean) f.getAttribute("errors")); }
public void testImportIntoDatabaseWithEncoding() throws Exception { Catalog cat = getCatalog(); DataStoreInfo ds = createH2DataStore(cat.getDefaultWorkspace().getName(), "ming"); File dir = tmpDir(); unpack("shape/ming_time.zip", dir); ImportContext context = importer.createContext(new Directory(dir), ds); assertEquals(1, context.getTasks().size()); context.getTasks().get(0).getData().setCharsetEncoding("UTF-8"); importer.run(context); FeatureTypeInfo info = (FeatureTypeInfo) context.getTasks().get(0).getLayer().getResource(); FeatureSource<? extends FeatureType, ? extends Feature> fs = info.getFeatureSource(null, null); FeatureCollection<? extends FeatureType, ? extends Feature> features = fs.getFeatures(); FeatureIterator<? extends Feature> it = features.features(); assertTrue(it.hasNext()); SimpleFeature next = (SimpleFeature) it.next(); // let's test some attributes to see if they were digested properly String type_ch = (String) next.getAttribute("type_ch"); assertEquals("卫", type_ch); String name_ch = (String) next.getAttribute("name_ch"); assertEquals("杭州前卫", name_ch); it.close(); }
@Test public void testGetFeaturesFeatureSource() throws Exception { // check the schemas in feature source and feature collection SimpleFeatureSource fs = rts.getFeatureSource(RENAMED); assertEquals(primitive, fs.getSchema()); SimpleFeatureCollection fc = fs.getFeatures(); assertEquals(primitive, fc.getSchema()); assertTrue(fc.size() > 0); // make sure the feature schema is good as well FeatureIterator<SimpleFeature> it = fc.features(); SimpleFeature sf = it.next(); it.close(); assertEquals(primitive, sf.getFeatureType()); // check the feature ids have been renamed as well assertTrue( "Feature id has not been renamed, it's still " + sf.getID(), sf.getID().startsWith(RENAMED)); // check mappings occurred assertEquals("description-f001", sf.getAttribute("description")); assertTrue( new WKTReader() .read("MULTIPOINT(39.73245 2.00342)") .equalsExact((Geometry) sf.getAttribute("pointProperty"))); assertEquals(new Long(155), sf.getAttribute("intProperty")); assertNull(sf.getAttribute("newProperty")); }
private void writeImplementation(SimpleFeature f) throws IOException { writer.next(); writer.writeFeatureID(f.getID()); for (int i = 0; i < f.getAttributeCount(); i++) { if (f.getAttribute(i) == null) writer.write(i, "<null>"); else writer.write(i, f.getAttribute(i)); } }
private void checkStackedPoint( Coordinate expectedCoordinate, int count, int countUnique, SimpleFeature f) { if (expectedCoordinate != null) { Point p = (Point) f.getDefaultGeometry(); assertEquals(expectedCoordinate, p.getCoordinate()); } assertEquals(count, f.getAttribute(PointStackerProcess.ATTR_COUNT)); assertEquals(countUnique, f.getAttribute(PointStackerProcess.ATTR_COUNT_UNIQUE)); }
@Override public void map(Text key, SimpleFeature value, Context context) throws IOException, InterruptedException { Counter counter = context.getCounter(CountersEnum.class.getName(), CountersEnum.FEATURES.toString()); counter.increment(1); Object[] values = new Object[] {value.getAttribute("dtg"), value.getAttribute("geom")}; SimpleFeature feature = new ScalaSimpleFeature(value.getID(), sft, values); context.write(text, feature); }
public void testLocalChanges() throws Exception { // apply a local change on Central so that we'll get a non empty transaction sent to the client VersioningFeatureStore restricted = (VersioningFeatureStore) synchStore.getFeatureSource("restricted"); SimpleFeatureType schema = restricted.getSchema(); // remove the third feature Id removeFilter = ff.id(singleton(ff.featureId("restricted.c15e76ab-e44b-423e-8f85-f6d9927b878a"))); restricted.removeFeatures(removeFilter); assertEquals(3, restricted.getCount(Query.ALL)); // build the expected PostDiff request QName typeName = new QName("http://www.openplans.org/spearfish", "restricted"); PostDiffType postDiff = new PostDiffType(); postDiff.setFromVersion(-1); postDiff.setToVersion(3); postDiff.setTypeName(typeName); TransactionType changes = WfsFactory.eINSTANCE.createTransactionType(); DeleteElementType delete = WfsFactory.eINSTANCE.createDeleteElementType(); delete.setTypeName(typeName); delete.setFilter(removeFilter); changes.getDelete().add(delete); postDiff.setTransaction(changes); // create mock objects that will check the calls are flowing as expected GSSClient client = createMock(GSSClient.class); expect(client.getCentralRevision((QName) anyObject())).andReturn(new Long(-1)); client.postDiff(postDiff); expect(client.getDiff((GetDiffType) anyObject())).andReturn(new GetDiffResponseType()); replay(client); GSSClientFactory factory = createMock(GSSClientFactory.class); expect(factory.createClient(new URL("http://localhost:8081/geoserver/ows"), null, null)) .andReturn(client); replay(factory); synch.clientFactory = factory; // perform synch Date start = new Date(); synch.synchronizeOustandlingLayers(); Date end = new Date(); // check we stored the last synch marker SimpleFeature f = getSingleFeature(fsUnitTables, ff.equal(ff.property("table_id"), ff.literal(1), false)); Date lastSynch = (Date) f.getAttribute("last_synchronization"); assertNotNull(lastSynch); assertTrue(lastSynch.compareTo(start) >= 0 && lastSynch.compareTo(end) <= 0); assertNull(f.getAttribute("last_failure")); // check we marked the unit as succeded f = getSingleFeature(fsUnits, ff.equal(ff.property("unit_name"), ff.literal("unit1"), false)); assertFalse((Boolean) f.getAttribute("errors")); }
public void testImportCSVIndirect() throws Exception { File dir = unpack("csv/locations.zip"); String wsName = getCatalog().getDefaultWorkspace().getName(); DataStoreInfo h2DataStore = createH2DataStore(wsName, "csvindirecttest"); SpatialFile importData = new SpatialFile(new File(dir, "locations.csv")); ImportContext context = importer.createContext(importData, h2DataStore); assertEquals(1, context.getTasks().size()); ImportTask task = context.getTasks().get(0); TransformChain transformChain = task.getTransform(); transformChain.add(new AttributesToPointGeometryTransform("LAT", "LON")); assertEquals(ImportTask.State.NO_CRS, task.getState()); LayerInfo layer = task.getLayer(); ResourceInfo resource = layer.getResource(); resource.setSRS("EPSG:4326"); assertTrue("Item not ready", importer.prep(task)); assertEquals(ImportTask.State.READY, task.getState()); context.updated(); assertEquals(ImportContext.State.PENDING, context.getState()); importer.run(context); assertEquals(ImportContext.State.COMPLETE, context.getState()); FeatureTypeInfo fti = (FeatureTypeInfo) resource; SimpleFeatureType featureType = (SimpleFeatureType) fti.getFeatureType(); GeometryDescriptor geometryDescriptor = featureType.getGeometryDescriptor(); assertNotNull("Expecting geometry", geometryDescriptor); assertEquals("Invalid geometry name", "location", geometryDescriptor.getLocalName()); assertEquals(3, featureType.getAttributeCount()); FeatureSource<? extends FeatureType, ? extends Feature> featureSource = fti.getFeatureSource(null, null); FeatureCollection<? extends FeatureType, ? extends Feature> features = featureSource.getFeatures(); assertEquals(9, features.size()); FeatureIterator<? extends Feature> featureIterator = features.features(); assertTrue("Expected features", featureIterator.hasNext()); SimpleFeature feature = (SimpleFeature) featureIterator.next(); assertNotNull(feature); assertEquals("Invalid city attribute", "Trento", feature.getAttribute("CITY")); assertEquals("Invalid number attribute", 140, feature.getAttribute("NUMBER")); Object geomAttribute = feature.getAttribute("location"); assertNotNull("Expected geometry", geomAttribute); Point point = (Point) geomAttribute; Coordinate coordinate = point.getCoordinate(); assertEquals("Invalid x coordinate", 11.12, coordinate.x, 0.1); assertEquals("Invalid y coordinate", 46.07, coordinate.y, 0.1); featureIterator.close(); }
private void addAttributeValues( SimpleFeature feature, List<String> retained, SimpleFeatureBuilder fb) { Iterator<AttributeDescriptor> firstIterator = feature.getType().getAttributeDescriptors().iterator(); while (firstIterator.hasNext()) { AttributeDescriptor ad = firstIterator.next(); Object firstAttribute = feature.getAttribute(ad.getLocalName()); if ((retained == null || retained.contains(ad.getLocalName())) && !(firstAttribute instanceof Geometry)) { fb.add(feature.getAttribute(ad.getLocalName())); } } }
public ZonalSystem(final String zonesShapeFileName) { final GeometryFactory geometryFactory = new GeometryFactory(); final WKTReader wktReader = new WKTReader(geometryFactory); for (SimpleFeature ft : ShapeFileReader.getAllFeatures(zonesShapeFileName)) { try { final String zoneId = ft.getAttribute("ZONE").toString(); final Zone zone = new Zone(zoneId); zone.setGeometry(wktReader.read((ft.getAttribute("the_geom")).toString())); this.id2zone.put(zoneId, zone); } catch (ParseException e) { throw new RuntimeException(e); } } }
public BugInfo(SimpleFeature next, long idx) throws IndexOutOfBoundsException, ParseException { bugId = idx; attributes = new HashMap<>(); Collection<Property> properties = next.getProperties(); Iterator<Property> it = properties.iterator(); while (it.hasNext()) { Property p = it.next(); attributes.put(p.getName().toString(), p.getValue().toString()); } this.geom = (Geometry) next.getAttribute(0); this.desc = (String) next.getAttribute("error_desc"); this.id = next.getID(); name = next.getName(); }
public ShapeElemtex(SimpleFeature f, String tipo) { super(f, tipo); shapeId = "ELEMTEX" + super.newShapeId(); // Elemtex trae la geometria en formato MultiLineString if (f.getDefaultGeometry() .getClass() .getName() .equals("com.vividsolutions.jts.geom.MultiLineString")) { MultiLineString l = (MultiLineString) f.getDefaultGeometry(); LineString line = new LineString(l.getCoordinates(), null, 0); coor = line.getEnvelopeInternal().centre(); } else { System.out.println( "[" + new Timestamp(new Date().getTime()) + "] Formato geometrico " + f.getDefaultGeometry().getClass().getName() + " desconocido dentro del shapefile ELEMTEX"); } // Los demas atributos son metadatos y de ellos sacamos ttggss = (String) f.getAttribute("TTGGSS"); // try { // rotulo = new String(f.getAttribute("ROTULO").toString().getBytes(), "UTF-8"); // rotulo = eliminarComillas(rotulo); // } catch (UnsupportedEncodingException e) {e.printStackTrace();} rotulo = eliminarComillas(f.getAttribute("ROTULO").toString()); // Dependiendo del ttggss se usa o no if (ttggss != null) { tags.addAll(ttggssParser(ttggss)); } // Si queremos coger todos los atributos del .shp // this.atributos = new ArrayList<ShapeAttribute>(); // for (int x = 1; x < f.getAttributes().size(); x++){ // atributos.add(new ShapeAttribute(f.getFeatureType().getDescriptor(x).getType(), // f.getAttributes().get(x))); // } }
private static void convertFeature( GeometryStreamConverter converter, SimpleFeature feature, List<String> keyAttributes, String projectionWKT) throws Exception { int shapeType = GeometryStreamUtils.getShapeTypeFromGeometryType( feature.getType().getType(0).getName().toString()); // get shape key by concatenating specified attributes String shapeKey = ""; for (int attrIndex = 0; attrIndex < keyAttributes.size(); attrIndex++) { Object attributeObject = feature.getAttribute(keyAttributes.get(attrIndex)); shapeKey += ShapefileUtilities.forAttribute(attributeObject, String.class); } IFeatureGeometryStream geomStream = new JTSFeatureGeometryStream((Geometry) feature.getDefaultGeometry()); converter.convertFeature(geomStream, shapeType, shapeKey, projectionWKT); /* if (debugDBF) { // debug: print data String attrs = geometryMetadata.shapeID + ", " + "\"" + shapeKey + '"'; for (int i = 1; i < feature.getAttributeCount(); i++) attrs += ", \"" + feature.getAttribute(i) + '"'; System.out.println(attrs); } if (debugCounts) { System.out.println(String.format("%s (geom %s) has %s vertices", shapeKey, i, coords.length)); } */ }
/** * Finds the geometric attribute requested by the symbolizer. * * @param feature The victim * @param symbolizer The symbolizer * @param style the resolved style for the specified victim * @return The geometry requested in the symbolizer, or the default geometry if none is specified */ private com.vividsolutions.jts.geom.Geometry findGeometry( SimpleFeature feature, Symbolizer symbolizer) { String geomName = getGeometryPropertyName(symbolizer); // get the geometry com.vividsolutions.jts.geom.Geometry geometry; if (geomName == null || feature.getType().getDescriptor(geomName) == null) { geometry = (Geometry) feature.getDefaultGeometry(); } else { geometry = (com.vividsolutions.jts.geom.Geometry) feature.getAttribute(geomName); } if (geometry == null) { return null; // nothing to see here } // if the symbolizer is a point or text symbolizer generate a suitable // location to place the // point in order to avoid recomputing that location at each rendering // step if ((symbolizer instanceof PointSymbolizer || symbolizer instanceof TextSymbolizer) && !(geometry instanceof Point)) { if (geometry instanceof LineString && !(geometry instanceof LinearRing)) { // use the mid point to represent the point/text symbolizer // anchor Coordinate[] coordinates = geometry.getCoordinates(); Coordinate start = coordinates[0]; Coordinate end = coordinates[1]; Coordinate mid = new Coordinate((start.x + end.x) / 2, (start.y + end.y) / 2); geometry = geometry.getFactory().createPoint(mid); } else { // otherwise use the centroid of the polygon geometry = geometry.getCentroid(); } } return geometry; }
/** * Put together a map of VPF files and their corresponding TableRows * * @param file * @param row */ private Map generateFileRowMap(VPFFile file, SimpleFeature row) throws IOException { String tileFileName = null; Map rows = new HashMap(); rows.put(file, row); Iterator joinIter = featureType.getFeatureClass().getJoinList().iterator(); while (joinIter.hasNext()) { ColumnPair columnPair = (ColumnPair) joinIter.next(); VPFFile primaryFile = getVPFFile(columnPair.column1); VPFFile joinFile = null; joinFile = getVPFFile(columnPair.column2); if (!rows.containsKey(joinFile) && rows.containsKey(primaryFile)) { SimpleFeature joinRow = (SimpleFeature) rows.get(primaryFile); try { int joinID = Integer.parseInt(joinRow.getAttribute(columnPair.column1.getName()).toString()); rows.put( joinFile, getVPFFile(columnPair.column2).getRowFromId(columnPair.column2.getName(), joinID)); } catch (NullPointerException exc) { // Non-matching joins - just put in a NULL rows.put(joinFile, null); } catch (IllegalAttributeException exc) { // I really don't expect to see this one exc.printStackTrace(); rows.put(joinFile, null); } } } return rows; }
/** * Sets the feature of the source. * * <p>This method operates by first clearing the contents of the feature store ({@link * #removeFeatures(Filter)}), and then obtaining an appending feature writer and writing all * features from <tt>reader</tt> to it. */ public final void setFeatures(FeatureReader<SimpleFeatureType, SimpleFeature> reader) throws IOException { // remove features removeFeatures(Filter.INCLUDE); // grab a feature writer for insert FeatureWriter<SimpleFeatureType, SimpleFeature> writer = getWriter(Filter.INCLUDE, WRITER_ADD); try { while (reader.hasNext()) { SimpleFeature feature = reader.next(); // grab next feature and populate it // JD: worth a note on how we do this... we take a "pull" approach // because the raw schema we are inserting into may not match the // schema of the features we are inserting SimpleFeature toWrite = writer.next(); for (int i = 0; i < toWrite.getType().getAttributeCount(); i++) { String name = toWrite.getType().getDescriptor(i).getLocalName(); toWrite.setAttribute(name, feature.getAttribute(name)); } // perform the write writer.write(); } } finally { writer.close(); } }
private static Object[] copyAttributes( SimpleFeatureType destSchema, SimpleFeature source, Map<String, Iterator<? extends Geometry>> geometries, Map<String, String> attributeMap, MathTransform mt) { Object[] attributes = new Object[destSchema.getAttributeCount()]; for (int i = 0; i < attributes.length; i++) { String sourceAttributeName = destSchema.getDescriptor(i).getName().getLocalPart(); String name = attributeMap.get(sourceAttributeName); if (name != null) attributes[i] = source.getAttribute(name); else { attributes[i] = destSchema.getDescriptor(i).getDefaultValue(); } if (attributes[i] instanceof Geometry) { Class<? extends Geometry> geomType = (Class<? extends Geometry>) destSchema.getDescriptor(i).getType().getBinding(); if (!geomType.isAssignableFrom(attributes[i].getClass())) { Collection<? extends Geometry> geom = createCompatibleGeometry((Geometry) attributes[i], geomType); Iterator<? extends Geometry> giter = geom.iterator(); attributes[i] = giter.next(); if (giter.hasNext()) geometries.put(sourceAttributeName, giter); } attributes[i] = transformGeom((Geometry) attributes[i], mt); } } return attributes; }
FeatureId addFeature( SimpleFeature feature, FeatureWriter<SimpleFeatureType, SimpleFeature> writer) throws IOException { // grab next feature and populate it // JD: worth a note on how we do this... we take a "pull" approach // because the raw schema we are inserting into may not match the // schema of the features we are inserting SimpleFeature toWrite = writer.next(); for (int i = 0; i < toWrite.getType().getAttributeCount(); i++) { String name = toWrite.getType().getDescriptor(i).getLocalName(); toWrite.setAttribute(name, feature.getAttribute(name)); } // copy over the user data if (feature.getUserData().size() > 0) { toWrite.getUserData().putAll(feature.getUserData()); } // pass through the fid if the user asked so boolean useExisting = Boolean.TRUE.equals(feature.getUserData().get(Hints.USE_PROVIDED_FID)); if (getQueryCapabilities().isUseProvidedFIDSupported() && useExisting) { ((FeatureIdImpl) toWrite.getIdentifier()).setID(feature.getID()); } // perform the write writer.write(); // copy any metadata from the feature that was actually written feature.getUserData().putAll(toWrite.getUserData()); // add the id to the set of inserted FeatureId id = toWrite.getIdentifier(); return id; }
/** * @param inputFeature * @return */ private int[] extractMultipleValues(SimpleFeature inputFeature, String attributeName) { if (inputFeature.getAttribute(attributeName) == null) { return new int[0]; } String[] svalues = inputFeature.getAttribute(attributeName).toString().split("\\|"); int[] values = new int[] {0, 0}; for (int count = 0; count < svalues.length; count++) { try { values[count] = Integer.parseInt(svalues[count]); } catch (NumberFormatException e) { } } return values; }
public Map<String, Zone> getZonesInsideBoundary(final String zonesBoundaryShapeFileName) { final Collection<SimpleFeature> features = ShapeFileReader.getAllFeatures(zonesBoundaryShapeFileName); if (features.size() != 1) { throw new RuntimeException("not exactly one feature in shape file"); } final SimpleFeature feature = features.iterator().next(); final WKTReader wktreader = new WKTReader(); final Geometry limitingPolygon; try { limitingPolygon = wktreader.read(feature.getAttribute("the_geom").toString()); } catch (ParseException e) { throw new RuntimeException(e); } final Map<String, Zone> result = new LinkedHashMap<String, Zone>(); for (Map.Entry<String, Zone> id2zoneEntry : this.id2zone.entrySet()) { if (limitingPolygon.covers(id2zoneEntry.getValue().getGeometry())) { result.put(id2zoneEntry.getKey(), id2zoneEntry.getValue()); } } return result; }
/** @see org.geotools.data.FeatureStore#setFeatures(org.geotools.data.FeatureReader) */ public void setFeatures(FeatureReader<SimpleFeatureType, SimpleFeature> reader) throws IOException { WFSTransactionState ts = null; if (trans == Transaction.AUTO_COMMIT) { ts = new WFSTransactionState(ds); } else { ts = (WFSTransactionState) trans.getState(ds); } ts.addAction( getSchema().getTypeName(), new DeleteAction(getSchema().getTypeName(), Filter.INCLUDE)); ReferencedEnvelope bounds = null; while (reader.hasNext()) { try { SimpleFeature f = reader.next(); List<AttributeDescriptor> atrs = f.getFeatureType().getAttributeDescriptors(); for (int i = 0; i < atrs.size(); i++) { if (atrs.get(i) instanceof GeometryDescriptor) { Geometry g = (Geometry) f.getAttribute(i); CoordinateReferenceSystem cs = ((GeometryDescriptor) atrs.get(i)).getCoordinateReferenceSystem(); if (cs != null && !cs.getIdentifiers().isEmpty()) g.setUserData(cs.getIdentifiers().iterator().next().toString()); if (g == null) continue; if (bounds == null) { bounds = new ReferencedEnvelope(g.getEnvelopeInternal(), cs); } else { bounds.expandToInclude(g.getEnvelopeInternal()); } } } ts.addAction(getSchema().getTypeName(), new InsertAction(f)); } catch (NoSuchElementException e) { WFS_1_0_0_DataStore.LOGGER.warning(e.toString()); } catch (IllegalAttributeException e) { WFS_1_0_0_DataStore.LOGGER.warning(e.toString()); } } // Fire a notification. // JE if (bounds == null) { // if bounds are null then send an envelope to say that features were added but // at an unknown location. bounds = new ReferencedEnvelope(getSchema().getCoordinateReferenceSystem()); ((WFS_1_0_0_DataStore) getDataStore()) .listenerManager.fireFeaturesRemoved( getSchema().getTypeName(), getTransaction(), bounds, false); } else { ((WFS_1_0_0_DataStore) getDataStore()) .listenerManager.fireFeaturesRemoved( getSchema().getTypeName(), getTransaction(), bounds, false); } if (trans == Transaction.AUTO_COMMIT) { ts.commit(); } }
@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 Filter createFilter(SimpleFeature feature, FeatureTypeRelation rel) { FilterFactory2 ff = CommonFactoryFinder.getFilterFactory2(); List<Filter> filters = new ArrayList<Filter>(); for (FeatureTypeRelationKey key : rel.getRelationKeys()) { AttributeDescriptor rightSide = key.getRightSide(); AttributeDescriptor leftSide = key.getLeftSide(); Object value = feature.getAttribute(leftSide.getName()); if (value == null) { continue; } if (AttributeDescriptor.GEOMETRY_TYPES.contains(rightSide.getType()) && AttributeDescriptor.GEOMETRY_TYPES.contains(leftSide.getType())) { filters.add(ff.not(ff.isNull(ff.property(rightSide.getName())))); filters.add(ff.intersects(ff.property(rightSide.getName()), ff.literal(value))); } else { filters.add(ff.equals(ff.property(rightSide.getName()), ff.literal(value))); } } if (filters.size() > 1) { return ff.and(filters); } else if (filters.size() == 1) { return filters.get(0); } else { return null; } }
@Override public FileGroup next() { SimpleFeature next = null; // look for cached feature if (cachedNext != null) { next = cachedNext; cachedNext = null; } else { next = featureIterator.next(); } // Avoid adding the feature to a collection to reduce memory consumption // we only take note of the firstFeature int groupedFeatures = 0; SimpleFeature firstFeature = null; // resolve the location String granuleLocation = (String) next.getAttribute(locationAttributeName); URL resolved = pathType.resolvePath(parentLocation, granuleLocation); File file = null; if (resolved != null) { file = DataUtilities.urlToFile(resolved); if (file != null && file.exists()) { groupedFeatures++; firstFeature = next; } } if (groupedFeatures == 0) { return null; } while (featureIterator.hasNext()) { // Group features sharing same location next = featureIterator.next(); String nextLocation = (String) next.getAttribute(locationAttributeName); if (granuleLocation.equalsIgnoreCase(nextLocation)) { groupedFeatures++; } else { cachedNext = next; break; } } // I have to group the features to get the ranges. return buildFileGroup(file, groupedFeatures > 1, firstFeature); }
/** * @param trace * @param dataStore * @param outputObjects * @param intValue * @param total * @param errors * @param geoName * @param aggregationLevel * @return * @throws IOException */ private int aggregateArcsOnGrid( int trace, DataStore dataStore, OutputObject[] outputObjects, int total, int errors, int startErrors, String outputName, int aggregationLevel) throws IOException { try { String inputGeometryName = getInputGeometryName(dataStore); SimpleFeature gridFeature = null; while ((gridFeature = readInput()) != null) { int id = nextId(); int idTematico = ((BigDecimal) gridFeature.getAttribute("gid")).intValue(); Geometry cell = (Geometry) gridFeature.getDefaultGeometry(); FeatureSource<SimpleFeatureType, SimpleFeature> reader = createInputReader(dataStore, Transaction.AUTO_COMMIT, null); FeatureIterator<SimpleFeature> iterator = reader .getFeatures( filterFactory.intersects( filterFactory.property(inputGeometryName), filterFactory.literal(cell))) .features(); try { errors = aggregateStep( trace, dataStore, outputObjects, total, errors, startErrors, outputName, id, idTematico, iterator, cell, false, true); } finally { iterator.close(); } } importFinished(total, errors - startErrors, "Data imported in " + outputName); } finally { closeInputReader(); } return errors; }