public void rollback(IProgressMonitor monitor) throws Exception { editBlackboard.removeGeometries(Collections.singleton(first)); EditGeom newGeom = editBlackboard.newGeom( oldshape.getEditGeom().getFeatureIDRef().get(), oldshape.getEditGeom().getShapeType()); for (int i = 0; i < oldshape.getNumCoords(); i++) { editBlackboard.addCoordinate(oldshape.getCoord(i), newGeom.getShell()); } if (currentShapeSet) setCurrentShape(newGeom.getShell()); FeatureStore<SimpleFeatureType, SimpleFeature> store = layer.getResource(FeatureStore.class, new SubProgressMonitor(monitor, 1)); FilterFactory factory = CommonFactoryFinder.getFilterFactory(GeoTools.getDefaultHints()); Set<FeatureId> ids = new HashSet<FeatureId>(); for (FeatureId id : newFids) { ids.add(id); } Id filter = factory.id(ids); store.removeFeatures(filter); Geometry oldType = (Geometry) oldFeature.getDefaultGeometry(); GeometryDescriptor newType = store.getSchema().getGeometryDescriptor(); store.modifyFeatures( newType, oldType, factory.id(FeatureUtils.stringToId(factory, oldFeature.getID()))); oldFeature.setDefaultGeometry(oldGeometry); newFids.clear(); }
/** * Analyzes the feature list, take the features that are neighbour and if they meet the * requirements, add a vertex to them. * * @return The builder instance. * @throws SplitFeatureBuilderFailException */ public SplitFeatureBuilder buildNeighbours() throws SplitFeatureBuilderFailException { this.neighbourResultList = new ArrayList<SimpleFeature>(); try { for (SimpleFeature feature : featureList) { Geometry geom = (Geometry) feature.getDefaultGeometry(); CoordinateReferenceSystem featureCRS = feature.getFeatureType().getCoordinateReferenceSystem(); geom = GeoToolsUtils.reproject(geom, featureCRS, desiredCRS); if (!canSplit(geom) && (requireVertex(geom))) { Geometry geomWithAddedVertex = addVertexToNeighbour(geom); geomWithAddedVertex = GeoToolsUtils.reproject(geomWithAddedVertex, desiredCRS, featureCRS); feature.setDefaultGeometry(geomWithAddedVertex); this.neighbourResultList.add(feature); } } } catch (Exception e) { throw makeFailException(e); } return this; }
/** * Creates the resultant features. * * @param splitGeometries List with the new geometries. * @param feature The old feature. * @throws OperationNotFoundException * @throws TransformException */ private List<SimpleFeature> createSplitFeatures( final List<Geometry> splitGeometries, final SimpleFeature feature) throws OperationNotFoundException, TransformException { final SimpleFeatureType featureType = feature.getFeatureType(); final CoordinateReferenceSystem featureCrs = featureType.getCoordinateReferenceSystem(); Class<? extends Geometry> geometryType = (Class<? extends Geometry>) featureType.getGeometryDescriptor().getType().getBinding(); List<SimpleFeature> splitFeatureList = new LinkedList<SimpleFeature>(); for (Geometry splittedPart : splitGeometries) { splittedPart = GeoToolsUtils.reproject(splittedPart, desiredCRS, featureCrs); splittedPart = GeometryUtil.adapt(splittedPart, geometryType); SimpleFeature newFeature = DataUtilities.template(featureType); GeoToolsUtils.copyAttributes(feature, newFeature); newFeature.setDefaultGeometry(splittedPart); splitFeatureList.add(newFeature); } return splitFeatureList; }
@Override public void actionPerformed(CommandEvent event) { JTextArea textArea = new JTextArea(16, 32); textArea.setEditable(true); JPanel contentPanel = new JPanel(new BorderLayout(4, 4)); contentPanel.add(new JLabel("Geometry Well-Known-Text (WKT):"), BorderLayout.NORTH); contentPanel.add(new JScrollPane(textArea), BorderLayout.CENTER); VisatApp visatApp = VisatApp.getApp(); ModalDialog modalDialog = new ModalDialog(visatApp.getApplicationWindow(), DLG_TITLE, ModalDialog.ID_OK_CANCEL, null); modalDialog.setContent(contentPanel); modalDialog.center(); if (modalDialog.show() == ModalDialog.ID_OK) { String wellKnownText = textArea.getText(); if (wellKnownText == null || wellKnownText.isEmpty()) { return; } ProductSceneView sceneView = visatApp.getSelectedProductSceneView(); VectorDataLayer vectorDataLayer = InsertFigureInteractorInterceptor.getActiveVectorDataLayer(sceneView); if (vectorDataLayer == null) { return; } SimpleFeatureType wktFeatureType = PlainFeatureFactory.createDefaultFeatureType(DefaultGeographicCRS.WGS84); ListFeatureCollection newCollection = new ListFeatureCollection(wktFeatureType); SimpleFeatureBuilder featureBuilder = new SimpleFeatureBuilder(wktFeatureType); SimpleFeature wktFeature = featureBuilder.buildFeature("ID" + Long.toHexString(currentFeatureId++)); Geometry geometry; try { geometry = new WKTReader().read(wellKnownText); } catch (ParseException e) { visatApp.handleError("Failed to convert WKT into geometry", e); return; } wktFeature.setDefaultGeometry(geometry); newCollection.add(wktFeature); FeatureCollection<SimpleFeatureType, SimpleFeature> productFeatures = FeatureUtils.clipFeatureCollectionToProductBounds( newCollection, sceneView.getProduct(), null, ProgressMonitor.NULL); if (productFeatures.isEmpty()) { visatApp.showErrorDialog(DLG_TITLE, "The geometry is not contained in the product."); } else { vectorDataLayer.getVectorDataNode().getFeatureCollection().addAll(productFeatures); } } }
@SuppressWarnings({"unchecked"}) private void modifyOldFeature(final FeatureStore<SimpleFeatureType, SimpleFeature> store) throws IOException, IllegalAttributeException { FilterFactory fac = CommonFactoryFinder.getFilterFactory(GeoTools.getDefaultHints()); Filter filter = fac.id(FeatureUtils.stringToId(fac, oldFeature.getID())); Geometry g = GeometryCreationUtil.createGeom(LineString.class, first.getShell(), true); if (store .getSchema() .getGeometryDescriptor() .getType() .getBinding() .isAssignableFrom(MultiLineString.class)) g = new GeometryFactory().createMultiLineString(new LineString[] {(LineString) g}); store.modifyFeatures(store.getSchema().getGeometryDescriptor(), g, filter); oldFeature.setDefaultGeometry(g); }
/** * Create a new Features from the provided coordinates and of the type indicated by geomType * * @param coordCRS The crs of the coordinates provided * @param destinationCRS The desired crs of the geometry * @param type the feature type of the object created * @param coordinates the coordinates that will be used to create the new feature * @param geomType the type of geometry that will be created * @return A new features. * @throws Exception */ public static <T extends Geometry> SimpleFeature createFeature( CoordinateReferenceSystem coordCRS, CoordinateReferenceSystem destinationCRS, SimpleFeatureType type, Coordinate[] coordinates, Class<T> geomType) throws Exception { transform(coordCRS, destinationCRS, coordinates); Object[] attrs = new Object[type.getAttributeCount()]; for (int i = 0; i < attrs.length; i++) { attrs[i] = setDefaultValue(type.getDescriptor(i)); } final SimpleFeature newFeature = SimpleFeatureBuilder.build(type, attrs, null); // Class geomType = type.getDefaultGeometry().getType(); T geom = GeometryBuilder.create().safeCreateGeometry(geomType, coordinates); newFeature.setDefaultGeometry(geom); return newFeature; }
/** * A new feature type using the attribute names of all joined feature type. * * @return a new feature type * @throws IllegalAttributeException * @throws SchemaException */ public SimpleFeature getFeature() throws IllegalAttributeException, SchemaException { SimpleFeatureType unionFeatureType = getFeatureType(); // adds the attributes values Object[] attrList = new Object[unionFeatureType.getAttributeCount()]; for (SimpleFeature feature : this.unionFeatures) { SimpleFeatureType featureType = feature.getFeatureType(); for (int j = 0; j < featureType.getAttributeCount(); j++) { // gets the attribute value AttributeDescriptor attrType = featureType.getDescriptor(j); if (!(attrType instanceof GeometryDescriptor)) { Object attrValue = feature.getAttribute(j); // gets the position in the union String unionAttrName = findAttributeName(featureType.getTypeName(), attrType.getLocalName()); int unionAttrPosition = unionFeatureType.indexOf(unionAttrName); // set the value in union attrList[unionAttrPosition] = attrValue; } } } // creates the new feature SimpleFeatureBuilder builder = new SimpleFeatureBuilder(unionFeatureType); builder.addAll(attrList); // SimpleFeature product = unionFeatureType.create(attrList); SimpleFeature product = builder.buildFeature(null); product.setDefaultGeometry(this.geometry); return product; }
@Override /** * @param inputData a HashMap of the input data: inputObservations: the observations * inputAuthoritativeData: the authoritative points inputDistance: the distance threshold * minNumber: the minimum number of named features to pass fieldName: the name of the field * within the observations to match * @result results a HashpMap of the results: result: the input data with the polygon attributes * attached, null values for no match qual_result: the matched input only data with polygon * attributes attached */ public Map<String, IData> run(Map<String, List<IData>> inputData) throws ExceptionReport { List obsList = inputData.get("inputObservations"); List authList = inputData.get("inputAuthoritativeData"); List distList = inputData.get("inputDistance"); List minList = inputData.get("minNumber"); List fieldList = inputData.get("fieldName"); FeatureCollection obsFc = ((GTVectorDataBinding) obsList.get(0)).getPayload(); FeatureCollection authFc = ((GTVectorDataBinding) authList.get(0)).getPayload(); double dist = ((LiteralDoubleBinding) distList.get(0)).getPayload(); int minNum = ((LiteralIntBinding) minList.get(0)).getPayload(); String fieldName = ((LiteralStringBinding) fieldList.get(0)).getPayload(); ArrayList<SimpleFeature> resultFeatures = new ArrayList<SimpleFeature>(); ArrayList<SimpleFeature> returnFeatures = new ArrayList<SimpleFeature>(); SimpleFeatureIterator obsIt = (SimpleFeatureIterator) obsFc.features(); SimpleFeatureIterator authIt = (SimpleFeatureIterator) authFc.features(); SimpleFeatureIterator sfi = (SimpleFeatureIterator) obsFc.features(); SimpleFeatureType fType = null; SimpleFeature tempPropFeature = sfi.next(); CoordinateReferenceSystem inputObsCrs = obsFc.getSchema().getCoordinateReferenceSystem(); Collection<Property> obsProp = tempPropFeature.getProperties(); SimpleFeatureTypeBuilder resultTypeBuilder = new SimpleFeatureTypeBuilder(); resultTypeBuilder.setName("typeBuilder"); resultTypeBuilder.setCRS(inputObsCrs); Iterator<Property> pItObs = obsProp.iterator(); sfi.close(); while (pItObs.hasNext() == true) { try { Property tempProp = pItObs.next(); PropertyType type = tempProp.getDescriptor().getType(); String name = type.getName().getLocalPart(); Class<String> valueClass = (Class<String>) tempProp.getType().getBinding(); resultTypeBuilder.add(name, valueClass); // LOG.warn ("Obs property " + name + " " + valueClass + " " +type.toString()); } catch (Exception e) { LOG.error("property error " + e); } } // add DQ_Field resultTypeBuilder.add("DQ_SA_SimilarF", Double.class); SimpleFeatureType typeF = resultTypeBuilder.buildFeatureType(); // LOG.warn("Get Spatial Accuracy Feature Type " + typeF.toString()); SimpleFeatureBuilder resultFeatureBuilder = new SimpleFeatureBuilder(typeF); obsIt.close(); SimpleFeatureIterator obsIt2 = (SimpleFeatureIterator) obsFc.features(); while (obsIt2.hasNext()) { SimpleFeature tempFeature = obsIt2.next(); fType = tempFeature.getType(); // LOG.warn("fieldName " + fieldName + " featureName " + featureN + " tempFeature Type " + // fType); // LOG.warn("TableFeatureName " + tempFeature.getProperty(fieldName).getValue()); String tempFeatureName = (String) tempFeature.getProperty(fieldName).getValue(); Geometry geom = (Geometry) tempFeature.getDefaultGeometry(); for (Property obsProperty : tempFeature.getProperties()) { String name = obsProperty.getName().toString(); Object value = obsProperty.getValue(); resultFeatureBuilder.set(name, value); } Geometry bufferGeom = geom.buffer(dist); SimpleFeatureIterator authIt2 = (SimpleFeatureIterator) authFc.features(); int count = 0; int within = 0; while (authIt2.hasNext() && count <= minNum) { SimpleFeature tempAuth = authIt2.next(); String featureN = (String) tempAuth.getProperty(fieldName).getValue(); Geometry tempGeom = (Geometry) tempAuth.getDefaultGeometry(); String authProperty = (String) tempAuth.getProperty(fieldName).getValue(); if (tempGeom.within(bufferGeom) && authProperty.equalsIgnoreCase(featureN)) { count++; if (count >= minNum) { within = 1; } } } LOG.warn("HERE " + within); resultFeatureBuilder.set("DQ_SA_SimilarF", within); SimpleFeature result = resultFeatureBuilder.buildFeature(tempFeature.getID()); result.setDefaultGeometry(geom); LOG.warn("HERE " + result); returnFeatures.add(result); if (within == 1) { resultFeatures.add(result); } authIt2.close(); } obsIt2.close(); ListFeatureCollection qualResult = new ListFeatureCollection(fType, resultFeatures); ListFeatureCollection returns = new ListFeatureCollection(fType, returnFeatures); LOG.warn("HERE 2 " + qualResult.size() + " " + returns.size()); Map<String, IData> results = new HashMap<String, IData>(); results.put("qual_result", new GTVectorDataBinding(qualResult)); results.put("result", new GTVectorDataBinding(returns)); return results; }
@Override /** * inputData a HashMap of the input data: * * @param inputObservations: the observations * @param inputAuthoritativeData: the polygons * @param bufferSize: the size of the buffer around the polygons results a HashpMap of the * results: * @result result: the input data with the polygon attributes attached, null values for no match * @result qual_result: the matched input only data with polygon attributes attached */ public Map<String, IData> run(Map<String, List<IData>> inputData) throws ExceptionReport { HashMap<String, Object> metadataMap = new HashMap<String, Object>(); ArrayList<SimpleFeature> list = new ArrayList<SimpleFeature>(); List<IData> inputObs = inputData.get("inputObservations"); List<IData> inputAuth = inputData.get("inputAuthoritativeData"); List<IData> inputLit = inputData.get("bufferSize"); IData observations = inputObs.get(0); IData authoritative = inputAuth.get(0); IData buffersize = inputLit.get(0); double doubleB = (Double) buffersize.getPayload(); FeatureCollection obsFC = ((GTVectorDataBinding) observations).getPayload(); FeatureCollection authFC = ((GTVectorDataBinding) authoritative).getPayload(); SimpleFeatureIterator obsIt = (SimpleFeatureIterator) obsFC.features(); SimpleFeatureIterator authIt = (SimpleFeatureIterator) authFC.features(); // setup result feature SimpleFeature obsItFeat = obsIt.next(); SimpleFeature obsItAuth = authIt.next(); Collection<Property> property = obsItFeat.getProperties(); Collection<Property> authProperty = obsItAuth.getProperties(); // setup result type builder SimpleFeatureTypeBuilder resultTypeBuilder = new SimpleFeatureTypeBuilder(); resultTypeBuilder.setName("typeBuilder"); Iterator<Property> pItObs = property.iterator(); Iterator<Property> pItAuth = authProperty.iterator(); metadataMap.put("element", "elementBufferedMetadata"); File metadataFile = createXMLMetadata(metadataMap); while (pItObs.hasNext() == true) { try { Property tempProp = pItObs.next(); PropertyType type = tempProp.getDescriptor().getType(); String name = type.getName().getLocalPart(); Class<String> valueClass = (Class<String>) tempProp.getType().getBinding(); resultTypeBuilder.add(name, valueClass); } catch (Exception e) { LOGGER.error("property error " + e); } } int i = 0; while (pItAuth.hasNext() == true) { try { Property tempProp = pItAuth.next(); PropertyType type = tempProp.getDescriptor().getType(); String name = type.getName().getLocalPart(); Class<String> valueClass = (Class<String>) tempProp.getType().getBinding(); if (i > 3) { resultTypeBuilder.add(name, valueClass); } i++; } catch (Exception e) { LOGGER.error("property error " + e); } } obsIt.close(); authIt.close(); resultTypeBuilder.add("withinBuffer", Integer.class); // set up result feature builder SimpleFeatureType type = resultTypeBuilder.buildFeatureType(); SimpleFeatureBuilder resultFeatureBuilder = new SimpleFeatureBuilder(type); // process data here: SimpleFeatureIterator obsIt2 = (SimpleFeatureIterator) obsFC.features(); int within = 0; FeatureCollection resultFeatureCollection = DefaultFeatureCollections.newCollection(); while (obsIt2.hasNext() == true) { within = 0; SimpleFeature tempObs = obsIt2.next(); Geometry obsGeom = (Geometry) tempObs.getDefaultGeometry(); for (Property obsProperty : tempObs.getProperties()) { String name = obsProperty.getName().getLocalPart(); Object value = obsProperty.getValue(); resultFeatureBuilder.set(name, value); // LOGGER.warn("obs Property set " + name); } double bufferSizeDouble = doubleB; Geometry bufferGeom = obsGeom.buffer(bufferSizeDouble); int j = 0; SimpleFeatureIterator authIt2 = (SimpleFeatureIterator) authFC.features(); while (authIt2.hasNext() == true) { SimpleFeature tempAuth = authIt2.next(); Geometry authGeom = (Geometry) tempAuth.getDefaultGeometry(); if (bufferGeom.intersects(authGeom) == true) { within = 1; j = 0; LOGGER.warn("Intersection = true"); for (Property authProperty1 : tempAuth.getProperties()) { String name = authProperty1.getName().getLocalPart(); Object value = authProperty1.getValue(); // Class valueClass = (Class<String>)authProperty1.getType().getBinding(); // LOGGER.warn("Auth property " + name); if (j > 3) { resultFeatureBuilder.set(name, value); // LOGGER.warn("Auth property set " + name); } j++; } } } resultFeatureBuilder.set("withinBuffer", within); SimpleFeature resultFeature = resultFeatureBuilder.buildFeature(tempObs.getName().toString()); Geometry geom = (Geometry) tempObs.getDefaultGeometry(); resultFeature.setDefaultGeometry(geom); list.add(resultFeature); // resultFeatureCollection.add(resultFeature); // LOGGER.warn("RESULT FEATURE " + resultFeatureCollection.getSchema().toString()); // resultFeatureCollection = obsFC; } ListFeatureCollection listFeatureCollection = new ListFeatureCollection(type, list); LOGGER.warn("Result Feature Size " + listFeatureCollection.size()); // sort HashMap GenericFileData gf = null; try { gf = new GenericFileData(metadataFile, "text/xml"); } catch (IOException e) { LOGGER.error("GenericFileData " + e); } HashMap<String, IData> results = new HashMap<String, IData>(); results.put("result", new GTVectorDataBinding((FeatureCollection) obsFC)); results.put("qual_result", new GTVectorDataBinding((FeatureCollection) listFeatureCollection)); results.put("metadata", new GenericFileDataBinding(gf)); return results; }
public UndoableMapCommand getCommand(EditToolHandler handler) { final PrimitiveShape currentShape = handler.getCurrentShape(); final ILayer editLayer = handler.getEditLayer(); // need to use map coordinates in order to avoid // possible inconsistencies between what the user // drawn and the projected result GeometryFactory gf = new GeometryFactory(); CoordinateReferenceSystem layerCrs = LayerUtil.getCrs(editLayer); CoordinateReferenceSystem mapCrs = editLayer.getMap().getViewportModel().getCRS(); Point p1 = gf.createPoint(currentShape.getCoord(0)); Point p2 = gf.createPoint(currentShape.getCoord(1)); Point p3 = gf.createPoint(currentShape.getCoord(2)); try { p1 = (Point) GeoToolsUtils.reproject(p1, layerCrs, mapCrs); p2 = (Point) GeoToolsUtils.reproject(p2, layerCrs, mapCrs); p3 = (Point) GeoToolsUtils.reproject(p3, layerCrs, mapCrs); } catch (OperationNotFoundException onfe) { throw new IllegalStateException( "Could not reproject to map crs:" + onfe.getLocalizedMessage(), onfe); } catch (TransformException te) { throw new IllegalStateException( "Could not reproject to map crs:" + te.getLocalizedMessage(), te); } ArcBuilder builder = new ArcBuilder(); builder.setPoints(p1.getX(), p1.getY(), p2.getX(), p2.getY(), p3.getX(), p3.getY()); // TODO: especificar la cantidad de segmentos por cuadrante // mediante una preferencia Geometry geom = builder.getGeometry(15); if (geom == null) { throw new IllegalStateException("null geom"); } // backproject resulting geom from map crs to layer's crs try { geom = GeoToolsUtils.reproject(geom, mapCrs, layerCrs); } catch (OperationNotFoundException onfe) { throw new IllegalStateException( "Could not reproject back to data crs:" + onfe.getLocalizedMessage(), onfe); } catch (TransformException te) { throw new IllegalStateException( "Could not reproject back to data crs:" + te.getLocalizedMessage(), te); } EditCommandFactory editCmdFac = AppGISMediator.getEditCommandFactory(); ILayer layer = editLayer; SimpleFeatureType schema = layer.getSchema(); SimpleFeature feature; try { feature = SimpleFeatureBuilder.build(schema, (Object[]) null, null); Class type = schema.getDefaultGeometry().getType().getBinding(); geom = GeometryUtil.adapt(geom, type); feature.setDefaultGeometry(geom); } catch (IllegalAttributeException e) { // consider using the bubble feedback throw new IllegalStateException("Could not create Arc:" + e, e); } UndoableMapCommand command = editCmdFac.createAddFeatureCommand(feature, layer); handler.setCurrentShape(null); handler.setCurrentState(EditState.NONE); return command; }
public void dumpBuffer(List<OSMEdge> edges, String filename) throws SchemaException, IOException { final SimpleFeatureType TYPE = DataUtilities.createType( "route", "location:LineString:srid=4326," + // <- the geometry attribute: Polyline type "name:String," + // <- a String attribute "number:Integer" // a number attribute ); // 1. build a feature SimpleFeatureBuilder featureBuilder = new SimpleFeatureBuilder(TYPE); ArrayList<SimpleFeature> features = new ArrayList<SimpleFeature>(); Iterator<OSMEdge> iter = edges.iterator(); while (iter.hasNext()) { OSMEdge o = iter.next(); SimpleFeature feature = featureBuilder.buildFeature(null); feature.setDefaultGeometry(o.getGeometry()); features.add(feature); } SimpleFeatureCollection collection = new ListFeatureCollection(TYPE, features); // FeatureCollections.newCollection(); logger.info("Writing to shapefile " + filename); File newFile = new File(filename); // File newFile = getNewShapeFile(file); ShapefileDataStoreFactory dataStoreFactory = new ShapefileDataStoreFactory(); Map<String, Serializable> params = new HashMap<String, Serializable>(); params.put("url", newFile.toURI().toURL()); params.put("create spatial index", Boolean.TRUE); ShapefileDataStore newDataStore = (ShapefileDataStore) dataStoreFactory.createNewDataStore(params); newDataStore.createSchema(TYPE); // You can comment out this line if you are using the createFeatureType method (at end of // class file) rather than DataUtilities.createType newDataStore.forceSchemaCRS(DefaultGeographicCRS.WGS84); Transaction transaction = new DefaultTransaction("create"); String typeName = newDataStore.getTypeNames()[0]; SimpleFeatureSource featureSource = newDataStore.getFeatureSource(typeName); if (featureSource instanceof SimpleFeatureStore) { SimpleFeatureStore featureStore = (SimpleFeatureStore) featureSource; featureStore.setTransaction(transaction); try { featureStore.addFeatures(collection); transaction.commit(); } catch (Exception problem) { problem.printStackTrace(); transaction.rollback(); } finally { transaction.close(); } // System.exit(0); // success! } else { logger.error(typeName + " does not support read/write access"); // System.exit(1); // exit program with status 1 (error) } }
@Execute /** * inputData a HashMap of the input data: * * @param inputObservations: the observations * @param inputAuthoritativeData: the polygons * @param bufferSize: the size of the buffer in the same units as the input data (degrees for * lat/long) results a HashpMap of the results: * @result result: the input data with the polygon attributes attached, null values for no match * @result qual_result: the matched input only data with polygon attributes attached * @result metadata: an unused output that was supposed to return an XML document for GeoNetwork */ public void runBuffer() { Logger LOGGER = Logger.getLogger(BufferAuthoritativeDataComparison.class); SimpleFeatureIterator obsIt = (SimpleFeatureIterator) obsFC.features(); SimpleFeatureIterator authIt = (SimpleFeatureIterator) authFC.features(); // setup result feature SimpleFeature obsItFeat = obsIt.next(); SimpleFeature obsItAuth = authIt.next(); Collection<Property> property = obsItFeat.getProperties(); Collection<Property> authProperty = obsItAuth.getProperties(); // setup result type builder SimpleFeatureTypeBuilder resultTypeBuilder = new SimpleFeatureTypeBuilder(); resultTypeBuilder.setName("typeBuilder"); Iterator<Property> pItObs = property.iterator(); Iterator<Property> pItAuth = authProperty.iterator(); metadataMap.put("element", "elementBufferedMetadata"); metadataFile = createXMLMetadata(metadataMap); while (pItObs.hasNext() == true) { try { Property tempProp = pItObs.next(); PropertyType type = tempProp.getDescriptor().getType(); String name = type.getName().getLocalPart(); Class<String> valueClass = (Class<String>) tempProp.getType().getBinding(); resultTypeBuilder.add(name, valueClass); } catch (Exception e) { LOGGER.error("property error " + e); } } int i = 0; while (pItAuth.hasNext() == true) { try { Property tempProp = pItAuth.next(); PropertyType type = tempProp.getDescriptor().getType(); String name = type.getName().getLocalPart(); Class<String> valueClass = (Class<String>) tempProp.getType().getBinding(); if (i > 3) { resultTypeBuilder.add(name, valueClass); } i++; } catch (Exception e) { LOGGER.error("property error " + e); } } obsIt.close(); authIt.close(); resultTypeBuilder.add("withinBuffer", Integer.class); // set up result feature builder SimpleFeatureType type = resultTypeBuilder.buildFeatureType(); SimpleFeatureBuilder resultFeatureBuilder = new SimpleFeatureBuilder(type); // process data here: SimpleFeatureIterator obsIt2 = (SimpleFeatureIterator) obsFC.features(); int within = 0; resultFeatureCollection = DefaultFeatureCollections.newCollection(); while (obsIt2.hasNext() == true) { within = 0; SimpleFeature tempObs = obsIt2.next(); Geometry obsGeom = (Geometry) tempObs.getDefaultGeometry(); for (Property obsProperty : tempObs.getProperties()) { String name = obsProperty.getName().getLocalPart(); Object value = obsProperty.getValue(); resultFeatureBuilder.set(name, value); // LOGGER.warn("obs Property set " + name); } double bufferSizeDouble = Double.parseDouble(bufferSize); Geometry bufferGeom = obsGeom.buffer(bufferSizeDouble); int j = 0; SimpleFeatureIterator authIt2 = (SimpleFeatureIterator) authFC.features(); while (authIt2.hasNext() == true) { SimpleFeature tempAuth = authIt2.next(); Geometry authGeom = (Geometry) tempAuth.getDefaultGeometry(); if (bufferGeom.intersects(authGeom) == true) { within = 1; j = 0; LOGGER.warn("Intersection = true"); for (Property authProperty1 : tempAuth.getProperties()) { String name = authProperty1.getName().getLocalPart(); Object value = authProperty1.getValue(); // Class valueClass = (Class<String>)authProperty1.getType().getBinding(); // LOGGER.warn("Auth property " + name); if (j > 3) { resultFeatureBuilder.set(name, value); // LOGGER.warn("Auth property set " + name); } j++; } } } resultFeatureBuilder.set("withinBuffer", within); SimpleFeature resultFeature = resultFeatureBuilder.buildFeature(tempObs.getName().toString()); Geometry geom = (Geometry) tempObs.getDefaultGeometry(); resultFeature.setDefaultGeometry(geom); list.add(resultFeature); // resultFeatureCollection.add(resultFeature); // LOGGER.warn("RESULT FEATURE " + resultFeatureCollection.getSchema().toString()); // resultFeatureCollection = obsFC; } listFeatureCollection = new ListFeatureCollection(type, list); LOGGER.warn("Result Feature Size " + listFeatureCollection.size()); }