@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(); }
public void testVectorReprojector() throws Exception { SimpleFeatureCollection testFC = HMTestMaps.testFC; OmsVectorReprojector reprojector = new OmsVectorReprojector(); reprojector.inVector = testFC; reprojector.pCode = "EPSG:4326"; reprojector.pm = pm; reprojector.process(); CoordinateReferenceSystem sourceCRS = HMTestMaps.crs; CoordinateReferenceSystem targetCRS = CRS.decode("EPSG:4326"); MathTransform transform = CRS.findMathTransform(sourceCRS, targetCRS); SimpleFeatureCollection outFC = reprojector.outVector; FeatureIterator<SimpleFeature> featureIterator = outFC.features(); SimpleFeatureIterator originalFeatureIterator = testFC.features(); while (featureIterator.hasNext()) { SimpleFeature feature = featureIterator.next(); Geometry geometry = (Geometry) feature.getDefaultGeometry(); Coordinate coordinate = geometry.getCoordinate(); SimpleFeature originalFeature = originalFeatureIterator.next(); Coordinate origCoord = ((Geometry) originalFeature.getDefaultGeometry()).getCoordinate(); Coordinate reprojected = JTS.transform(origCoord, null, transform); assertEquals(reprojected.x, coordinate.x, delta); assertEquals(reprojected.y, coordinate.y, delta); } featureIterator.close(); }
public static DelaunayNode[] featureCollectionToNodeArray(SimpleFeatureCollection fc) { SimpleFeatureIterator iter = fc.features(); int size = fc.size(); DelaunayNode[] nodes = new DelaunayNode[size]; int index = 0; while (iter.hasNext()) { SimpleFeature next = iter.next(); Geometry geom = (Geometry) next.getDefaultGeometry(); Point centroid; if (geom instanceof Point) { centroid = (Point) geom; } else { centroid = geom.getCentroid(); } DelaunayNode node = new DelaunayNode(); node.setCoordinate(centroid.getCoordinate()); node.setFeature(next); if (!(arrayContains(node, nodes, index))) { nodes[index] = node; index++; } } DelaunayNode[] trimmed = new DelaunayNode[index]; for (int i = 0; i < index; i++) { trimmed[i] = nodes[i]; } return trimmed; }
public void setupInstance(String shapeFileName) { File file = new File(shapeFileName); // TODO what if the file doesn't exist? ShapefileDataStore store = null; SimpleFeatureCollection collection = null; try { store = (ShapefileDataStore) FileDataStoreFinder.getDataStore(file); SimpleFeatureSource featureSource = store.getFeatureSource(); collection = featureSource.getFeatures(); } catch (IOException e) { logger.error("Could not retrieve collection", e); return; } geometryFactory = new GeometryFactory(); geometryList = new ArrayList<Geometry>(); SimpleFeatureIterator iter = collection.features(); while (iter.hasNext()) { SimpleFeature feature = iter.next(); Geometry geometry = (Geometry) feature.getDefaultGeometry(); geometryList.add(geometry); } iter.close(); }
@Test public void testWithNull() throws Exception { SimpleFeatureSource source = getFeatureSource(MockData.BASIC_POLYGONS); SimpleFeatureCollection fc = source.getFeatures(); SimpleFeatureIterator i = fc.features(); try { SimpleFeature f = (SimpleFeature) i.next(); FeatureTemplate template = new FeatureTemplate(); template.description(f); // set a value to null f.setAttribute(1, null); try { template.description(f); } catch (Exception e) { e.printStackTrace(); fail("template threw exception on null value"); } } finally { i.close(); } }
public static SimpleFeatureType toReShapeFeatureType( SimpleFeatureCollection delegate, List<Definition> definitionList) { SimpleFeature sample = null; SimpleFeatureIterator iterator = delegate.features(); try { if (iterator.hasNext()) { sample = iterator.next(); } } finally { iterator.close(); // good bye } SimpleFeatureTypeBuilder build = new SimpleFeatureTypeBuilder(); SimpleFeatureType origional = delegate.getSchema(); for (Definition def : definitionList) { String name = def.name; Expression expression = def.expression; Object value = null; if (sample != null) { value = expression.evaluate(sample); } Class<?> binding = def.binding; // make use of any default binding hint provided by user if (value == null) { if (expression instanceof PropertyName) { PropertyName propertyName = (PropertyName) expression; String path = propertyName.getPropertyName(); AttributeDescriptor descriptor = origional.getDescriptor(name); AttributeType attributeType = descriptor.getType(); binding = attributeType.getBinding(); } } else { binding = value.getClass(); } if (binding == null) { // note we could consider scanning through additional samples until we get a non null hit throw new IllegalArgumentException("Unable to determine type for " + name); } if (Geometry.class.isAssignableFrom(binding)) { CoordinateReferenceSystem crs; AttributeType originalAttributeType = origional.getType(name); if (originalAttributeType != null && originalAttributeType instanceof GeometryType) { GeometryType geometryType = (GeometryType) originalAttributeType; crs = geometryType.getCoordinateReferenceSystem(); } else { crs = origional.getCoordinateReferenceSystem(); } build.crs(crs); build.add(name, binding); } else { build.add(name, binding); } } build.setName(origional.getTypeName()); return build.buildFeatureType(); }
/** * Creates a buffer from the source shapefile MultiPolygon2 and put the result on the existent * shapefile TargetMultiPolygonForBuffer. * * <p>Check that the featureStore isn't empty and the geometry of the resultant features is * MultiPolygon. * * @throws IOException * @throws SchemaException * @throws InterruptedException * @throws ExecutionException */ @Test public void testBufferTask() throws IOException, SchemaException, InterruptedException, ExecutionException { // initialize the parameters firstShp = "MultiPolygon2.shp"; targetShp = TASK_PATH + "TargetMultiPolygonForBuffer.shp"; isCreatingNewLayer = false; width = 10.0; unitOfMeasure = valueOfUnit("m"); mergeGeometries = false; quadrantSegments = 8; capStyle = CapStyle.capRound; initTaskParameters(); assertNotNull(task); assertNotNull(targetStore); // execute runTask(); // obtain the result and check the data. SimpleFeatureStore resultStore = (SimpleFeatureStore) future.get(); assertNotNull(resultStore); SimpleFeatureCollection fc = null; SimpleFeatureIterator it = null; try { fc = resultStore.getFeatures(); assertFalse(fc.isEmpty()); assertTrue(fc.size() > 0); it = fc.features(); while (it.hasNext()) { SimpleFeature f = it.next(); assertTrue(f.getDefaultGeometry().getClass() == MultiPolygon.class); } } catch (IOException e) { throw e; } finally { if (it != null) { it.close(); } } }
private void checkSorted( SortedSimpleFeatureCollection sorted, Comparator<SimpleFeature> comparator) { SimpleFeatureIterator fi = sorted.features(); SimpleFeature prev = null; while (fi.hasNext()) { SimpleFeature curr = fi.next(); if (prev != null) { assertTrue("Failed on " + prev + " / " + curr, comparator.compare(prev, curr) <= 0); } prev = curr; } fi.close(); }
/** * <b>validateMultipleLayers Purpose:</b> <br> * * <p>This validation tests for a geometry containing another geometry. Uses JTS' * Geometry.contains(Geometry) method. DE-9IM intersection matrix is T*F**F***. * <b>Description:</b><br> * * <p>The function filters the FeatureSources using the given bounding box. It creates iterators * over both filtered FeatureSources. It calls contains() using the geometries in the * SimpleFeatureSource layers. Tests the results of the method call against the given expected * results. Returns true if the returned results and the expected results are true, false * otherwise. Author: bowens<br> * Created on: Apr 27, 2004<br> * * @param featureSourceA - the SimpleFeatureSource to pull the original geometries from. This * geometry is the one that is tested for containing the other * @param featureSourceB - the SimpleFeatureSource to pull the other geometries from - these * geometries will be those that may be contained within the first geometry * @param expected - boolean value representing the user's expected outcome of the test * @param results - ValidationResults * @param bBox - Envelope - the bounding box within which to perform the contains() * @return boolean result of the test * @throws Exception - IOException if iterators improperly closed */ private boolean validateMultipleLayers( SimpleFeatureSource featureSourceA, SimpleFeatureSource featureSourceB, boolean expected, ValidationResults results, Envelope bBox) throws Exception { boolean success = true; FilterFactory ff = CommonFactoryFinder.getFilterFactory(null); Filter filter = null; SimpleFeatureCollection featureResultsA = featureSourceA.getFeatures(filter); SimpleFeatureCollection featureResultsB = featureSourceB.getFeatures(filter); SimpleFeatureIterator fr1 = null; SimpleFeatureIterator fr2 = null; try { fr1 = featureResultsA.features(); if (fr1 == null) return false; while (fr1.hasNext()) { SimpleFeature f1 = fr1.next(); Geometry g1 = (Geometry) f1.getDefaultGeometry(); fr2 = featureResultsB.features(); try { while (fr2 != null && fr2.hasNext()) { SimpleFeature f2 = fr2.next(); Geometry g2 = (Geometry) f2.getDefaultGeometry(); if (g1.contains(g2) != expected) { results.error( f1, ((Geometry) f1.getDefaultGeometry()).getGeometryType() + " " + getGeomTypeRefA() + " contains " + getGeomTypeRefB() + "(" + f2.getID() + "), Result was not " + expected); success = false; } } } finally { fr2.close(); } } } finally { fr1.close(); fr2.close(); } return success; }
private Map<String, Double> fetchPointValues(KmlFeature feature, List<String> parameters) { try { SimpleFeatureIterator iterator = getIterator(); while (iterator.hasNext()) { SimpleFeature shape = iterator.next(); Geometry geometry = (Geometry) shape.getDefaultGeometry(); if (geometry.contains(feature.getGeometry())) return fetchValues(shape, parameters); } return Collections.emptyMap(); } catch (Exception e) { log.error("failed to fetch point values", e); return Collections.emptyMap(); } }
private Id createFidFilter(SimpleFeatureSource fs) throws IOException { SimpleFeatureIterator iter = fs.getFeatures().features(); FilterFactory2 ffac = CommonFactoryFinder.getFilterFactory2(GeoTools.getDefaultHints()); Set fids = new HashSet(); try { while (iter.hasNext()) { String id = iter.next().getID(); FeatureId fid = ffac.featureId(id); fids.add(fid); } Id filter = ffac.id(fids); return filter; } finally { iter.close(); } }
@Test public void testAlternateLookup() throws Exception { SimpleFeatureSource source = getFeatureSource(MockData.PRIMITIVEGEOFEATURE); SimpleFeatureCollection fc = source.getFeatures(); SimpleFeatureIterator features = fc.features(); try { SimpleFeature f = features.next(); FeatureTemplate template = new FeatureTemplate(); String result = template.template(f, "dummy.ftl", Dummy.class); assertEquals("dummy", result); } finally { features.close(); } }
@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); }
@Test public void testTypes() throws IOException, NoSuchElementException { if (url == null) return; WFS_1_0_0_DataStore wfs; try { wfs = WFSDataStoreReadTest.getDataStore(url); } catch (ConnectException e) { e.printStackTrace(System.err); return; } catch (UnknownHostException e) { e.printStackTrace(System.err); return; } catch (NoRouteToHostException e) { e.printStackTrace(System.err); return; } String types[] = wfs.getTypeNames(); String typeName = "unknown"; for (int i = 0; i < types.length; i++) { typeName = types[i]; if (typeName.equals("topp:geometrytype")) continue; SimpleFeatureType type = wfs.getSchema(typeName); type.getTypeName(); type.getName().getNamespaceURI(); SimpleFeatureSource source = wfs.getFeatureSource(typeName); source.getBounds(); SimpleFeatureCollection features = source.getFeatures(); features.getBounds(); features.getSchema(); // features.getFeatureType(); Query query = new Query(typeName, Filter.INCLUDE, 20, Query.ALL_NAMES, "work already"); features = source.getFeatures(query); features.size(); SimpleFeatureIterator iterator = features.features(); try { while (iterator.hasNext()) { SimpleFeature feature = (SimpleFeature) iterator.next(); } } finally { iterator.close(); } } }
/** * Get the stacked point closest to the provided coordinate * * @param result * @param coordinate * @param i * @param j */ private SimpleFeature getResultPoint(SimpleFeatureCollection result, Coordinate testPt) { /** Find closest point to loc pt, then check that the attributes match */ double minDist = Double.MAX_VALUE; // find nearest result to testPt SimpleFeature closest = null; for (SimpleFeatureIterator it = result.features(); it.hasNext(); ) { SimpleFeature f = it.next(); Coordinate outPt = ((Point) f.getDefaultGeometry()).getCoordinate(); double dist = outPt.distance(testPt); if (dist < minDist) { closest = f; minDist = dist; } } return closest; }
@Test public void testRawValue() throws Exception { SimpleFeatureSource source = getFeatureSource(MockData.PRIMITIVEGEOFEATURE); SimpleFeatureCollection fc = source.getFeatures(); SimpleFeatureIterator i = fc.features(); try { SimpleFeature f = (SimpleFeature) i.next(); FeatureTemplate template = new FeatureTemplate(); try { template.template(f, "rawValues.ftl", FeatureTemplateTest.class); } catch (Exception e) { e.printStackTrace(); throw (e); } } finally { i.close(); } }
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; }
public static void printID(String filename) { File file = new File(filename); FileDataStore store = null; try { store = FileDataStoreFinder.getDataStore(file); } catch (IOException e) { // TODO Auto-generated catch block e.printStackTrace(); } SimpleFeatureSource featureSource = null; try { featureSource = store.getFeatureSource(); } catch (IOException e) { // TODO Auto-generated catch block e.printStackTrace(); } SimpleFeatureCollection featureCollection = null; try { featureCollection = featureSource.getFeatures(); } catch (IOException e) { // TODO Auto-generated catch block e.printStackTrace(); } // get features from source int sizeFeatureCollection = featureCollection.size(); System.out.println( "The number of features in the shapefile is: " + sizeFeatureCollection + "."); SimpleFeatureIterator iterator = featureCollection.features(); // List<Geometry> GeometryList = new ArrayList<Geometry>(sizeFeatureCollection); try { while (iterator.hasNext()) { SimpleFeature feature = iterator.next(); System.out.println(feature.getID()); } } finally { iterator.close(); store.dispose(); } }
@Test public void testAttributeReader() throws IOException { URL u = TestData.url(TestCaseSupport.class, SHPFILE); File shpFile = DataUtilities.urlToFile(u); // open the test shapefile ShapefileDataStore store = new ShapefileDataStore(shpFile.toURI().toURL()); SimpleFeatureSource source = store.getFeatureSource(); // read the first feature SimpleFeatureIterator iter = source.getFeatures().features(); SimpleFeature feature = iter.next(); iter.close(); // get the value of the duplicate column & compare it against expectation assertEquals(expectedValue, feature.getAttribute(testColumn)); // cleanup store.dispose(); }
private Map<String, Double> fetchPolygonValues(KmlFeature feature, List<String> parameters) { try { double totalArea = feature.getGeometry().getArea(); if (totalArea == 0) return Collections.emptyMap(); Map<SimpleFeature, Double> shares = new HashMap<>(); SimpleFeatureIterator iterator = getIterator(); while (iterator.hasNext()) { SimpleFeature shape = iterator.next(); Geometry shapeGeo = (Geometry) shape.getDefaultGeometry(); Geometry featureGeo = feature.getGeometry(); if (!featureGeo.intersects(shapeGeo)) continue; double area = featureGeo.intersection(shapeGeo).getArea(); shares.put(shape, area / totalArea); } return fetchValues(shares, parameters); } catch (Exception e) { log.error("failed to fetch polygon parameters", e); return Collections.emptyMap(); } }
@Test public void testWithDateAndBoolean() throws Exception { SimpleFeatureSource source = getFeatureSource(MockData.PRIMITIVEGEOFEATURE); SimpleFeatureCollection fc = source.getFeatures(); SimpleFeatureIterator i = fc.features(); try { SimpleFeature f = (SimpleFeature) i.next(); FeatureTemplate template = new FeatureTemplate(); try { template.description(f); } catch (Exception e) { e.printStackTrace(); fail("template threw exception on null value"); } } finally { i.close(); } }
/** * Gets the allocation rule. * * @return the allocation rule * @throws Exception the exception */ @Test( enabled = true, groups = {"setup", "geo", "database"}) public void getAllocationRule() throws Exception { LOGGER.debug("getAllocationRule: {}"); final AllocationScenario allocationScenario = allocationScenarioService.getAllocationScenario(WifKeys.TEST_ALLOCATION_SCENARIO_ID); final AllocationLU residentiallu = project.getExistingLandUseByLabel("Conservation"); final String existingLULabel = project.getExistingLUAttributeName(); final String scoreLabel = residentiallu.getAssociatedLU().getFeatureFieldName(); final ALURule rule = geodataFilterer.getAllocationRule( residentiallu, allocationScenario, scoreLabel, existingLULabel, "", "", null, 0.0); final Query ruleQuery = rule.getRuleQuery(); // ruleQuery. final SimpleFeatureCollection sortedUazCollection = featureStore.getFeatures(rule.getRuleQuery()); LOGGER.debug("sortedUazCollection size: {}", sortedUazCollection.size()); // Assert.assertEquals(sortedUazCollection.size(), 7834); final SimpleFeatureIterator its = sortedUazCollection.features(); // 2. for each ORDERED UAZ int remaining = 0; final String areaLabel = allocationScenario.getWifProject().getAreaLabel(); while (its.hasNext() && remaining < 10) { // 3. while there is a still area to allocate final SimpleFeature uazFeature = its.next(); final String id = uazFeature.getID(); LOGGER.debug("Allocating feature id: {}", id); final Double featureArea = (Double) uazFeature.getAttribute(areaLabel); LOGGER.debug( "feature suitability score= {}, feature area = {},", uazFeature.getAttribute(scoreLabel), featureArea); remaining++; } }
@Test public void testSingleType() throws IOException, NoSuchElementException { if (url == null) return; WFS_1_0_0_DataStore wfs; try { wfs = WFSDataStoreReadTest.getDataStore(url); } catch (ConnectException e) { e.printStackTrace(System.err); return; } catch (UnknownHostException e) { e.printStackTrace(System.err); return; } catch (NoRouteToHostException e) { e.printStackTrace(System.err); return; } String typeName = "tiger:poi"; SimpleFeatureType type = wfs.getSchema(typeName); type.getTypeName(); type.getName().getNamespaceURI(); SimpleFeatureSource source = wfs.getFeatureSource(typeName); source.getBounds(); SimpleFeatureCollection features = source.getFeatures(); features.getBounds(); features.getSchema(); // features.getFeatureType(); Query query = new Query(typeName, Filter.INCLUDE, 20, Query.ALL_NAMES, "work already"); features = source.getFeatures(query); features.size(); SimpleFeatureIterator iterator = features.features(); while (iterator.hasNext()) { SimpleFeature feature = iterator.next(); } iterator.close(); }
@Test public void testSimplifyFilter() throws Exception { if (url == null) return; Map m = new HashMap(); m.put(WFSDataStoreFactory.URL.key, url); m.put(WFSDataStoreFactory.TIMEOUT.key, new Integer(100000)); WFS_1_0_0_DataStore wfs = (WFS_1_0_0_DataStore) (new WFSDataStoreFactory()).createDataStore(m); FilterFactory2 ff = CommonFactoryFinder.getFilterFactory2(GeoTools.getDefaultHints()); WFSFeatureSource fs = wfs.getFeatureSource("topp:states"); // build a filter with bits that cannot be encoded in OGC filter, but can be simplified // to one that can Filter f = ff.or( Arrays.asList( Filter.EXCLUDE, ff.and(Filter.INCLUDE, ff.greater(ff.property("PERSONS"), ff.literal(10000000))))); SimpleFeatureCollection fc = fs.getFeatures(f); // force calling a HITS query, it used to throw an exception int size = fc.size(); // force making a GetFeature, it used to blow up SimpleFeatureIterator fi = null; try { fi = fc.features(); if (fi.hasNext()) { fi.next(); } } finally { if (fi != null) { fi.close(); } } }
public void testAssorted() { TreeSetFeatureCollection copy = new TreeSetFeatureCollection(); copy.addAll(features); copy.clear(); assertTrue(copy.isEmpty()); copy.addAll(features); assertTrue(!copy.isEmpty()); List<SimpleFeature> list = DataUtilities.list(features); SimpleFeature[] f1 = (SimpleFeature[]) list.toArray(new SimpleFeature[list.size()]); SimpleFeature[] f2 = (SimpleFeature[]) features.toArray(new SimpleFeature[list.size()]); assertEquals(f1.length, f2.length); for (int i = 0; i < f1.length; i++) { assertSame(f1[i], f2[i]); } SimpleFeatureIterator copyIterator = copy.features(); SimpleFeatureIterator featuresIterator = features.features(); while (copyIterator.hasNext() && featuresIterator.hasNext()) { assertEquals(copyIterator.next(), featuresIterator.next()); } }
@Override public void close() throws IOException { featureIterator.close(); }
@Override public boolean hasNext() { return featureIterator.hasNext() || cachedNext != null; }
public boolean hasNext() { // logger.info("qui"); logger.finer("HAS NEXT"); while ((next == null && delegate.hasNext()) || (next == null && added)) { // logger.info("qui nel while"); if (complete) { first = delegate.next(); intersectedGeometries = null; } // logger.info("qui dopo check if (complete)"); // logger.finer("control HAS NEXT"); for (Object attribute : first.getAttributes()) { if (attribute instanceof Geometry && attribute.equals(first.getDefaultGeometry())) { Geometry currentGeom = (Geometry) attribute; if (intersectedGeometries == null && !added) { intersectedGeometries = filteredCollection(currentGeom, subFeatureCollection); iterator = intersectedGeometries.features(); } try { while (iterator.hasNext()) { added = false; SimpleFeature second = iterator.next(); if (currentGeom .getEnvelope() .intersects(((Geometry) second.getDefaultGeometry()))) { // compute geometry if (intersectionMode == IntersectionMode.INTERSECTION) { attribute = currentGeom.intersection((Geometry) second.getDefaultGeometry()); GeometryFilterImpl filter = new GeometryFilterImpl(geomType.getType().getBinding()); ((Geometry) attribute).apply(filter); attribute = filter.getGeometry(); } else if (intersectionMode == IntersectionMode.FIRST) { attribute = currentGeom; } else if (intersectionMode == IntersectionMode.SECOND) { attribute = (Geometry) second.getDefaultGeometry(); } if (((Geometry) attribute).getNumGeometries() > 0) { fb.add(attribute); fb.set("INTERSECTION_ID", id++); // add the non geometric attributes addAttributeValues(first, retainAttributesFst, fb); addAttributeValues(second, retainAttributesSnd, fb); // add the dynamic attributes if (percentagesEnabled) { addPercentages(currentGeom, second); } if (areasEnabled) { addAreas(currentGeom, second); } // build the feature next = fb.buildFeature(iterationIndex.toString()); // update iterator status if (iterator.hasNext()) { complete = false; added = true; iterationIndex++; return next != null; } iterationIndex++; } } complete = false; } complete = true; } finally { if (!added) { iterator.close(); } } } } } return next != null; }
public void close() { delegate.close(); }
@SuppressWarnings("unchecked") public void _testParseGetFeature() throws Exception { File tmp = File.createTempFile("geoserver-DescribeFeatureType", "xml"); tmp.deleteOnExit(); InputStream in = getClass().getResourceAsStream("geoserver-DescribeFeatureType.xml"); Files.copy(in, tmp.toPath()); in = getClass().getResourceAsStream("geoserver-GetFeature.xml"); DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance(); dbf.setNamespaceAware(true); DocumentBuilder db = dbf.newDocumentBuilder(); Document doc = db.parse(in); // http://cite.opengeospatial.org/gmlsf // http://localhost:8080/geoserver/wfs?service=WFS&version=1.1.0&request=DescribeFeatureType&typeName=sf:PrimitiveGeoFeature String schemaLocation = doc.getDocumentElement() .getAttributeNS("http://www.w3.org/2001/XMLSchema-instance", "schemaLocation"); String absolutePath = DataUtilities.fileToURL(tmp).toExternalForm(); schemaLocation = schemaLocation.replaceAll( "http://cite.opengeospatial.org/gmlsf .*", "http://cite.opengeospatial.org/gmlsf " + absolutePath); doc.getDocumentElement() .setAttributeNS( "http://www.w3.org/2001/XMLSchema-instance", "schemaLocation", schemaLocation); tmp = File.createTempFile("geoserver-GetFeature", "xml"); tmp.deleteOnExit(); Transformer tx = TransformerFactory.newInstance().newTransformer(); tx.transform(new DOMSource(doc), new StreamResult(tmp)); in = new FileInputStream(tmp); Parser parser = new Parser(configuration); FeatureCollectionType fc = (FeatureCollectionType) parser.parse(in); assertNotNull(fc); List featureCollections = fc.getMember(); assertEquals(1, featureCollections.size()); SimpleFeatureCollection featureCollection; featureCollection = (SimpleFeatureCollection) featureCollections.get(0); assertEquals(5, featureCollection.size()); SimpleFeatureIterator features = featureCollection.features(); try { assertTrue(features.hasNext()); SimpleFeature f = features.next(); assertEquals("PrimitiveGeoFeature.f001", f.getID()); assertNull(f.getDefaultGeometry()); assertNotNull(f.getAttribute("pointProperty")); Point p = (Point) f.getAttribute("pointProperty"); assertEquals(39.73245, p.getX(), 0.1); assertEquals(2.00342, p.getY(), 0.1); Object intProperty = f.getAttribute("intProperty"); assertNotNull(intProperty); assertTrue(intProperty.getClass().getName(), intProperty instanceof BigInteger); assertEquals(BigInteger.valueOf(155), intProperty); assertEquals(new URI("http://www.opengeospatial.org/"), f.getAttribute("uriProperty")); assertEquals(new Float(12765.0), f.getAttribute("measurand")); assertTrue(f.getAttribute("dateProperty") instanceof Date); assertEquals(BigDecimal.valueOf(5.03), f.getAttribute("decimalProperty")); } finally { features.close(); } }