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());
}