org.jgrasstools.gears.modules.v.vectorreshaper.OmsVectorReshaper Maven / Gradle / Ivy
The newest version!
/*
* This file is part of JGrasstools (http://www.jgrasstools.org)
* (C) HydroloGIS - www.hydrologis.com
*
* JGrasstools is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see removeNames = new ArrayList();
if (pRemove != null) {
String[] split = pRemove.split(",");
for( String string : split ) {
removeNames.add(string.trim());
}
}
final SimpleFeatureType originalFeatureType = inVector.getSchema();
List attributeDescriptors = originalFeatureType.getAttributeDescriptors();
LinkedHashMap functionMap = new LinkedHashMap();
for( AttributeDescriptor attributeDescriptor : attributeDescriptors ) {
String name = attributeDescriptor.getLocalName();
if (removeNames.contains(name.trim())) {
continue;
}
functionMap.put(name, name);
}
if (pCql != null && pCql.length() > 0) {
String[] split = pCql.trim().split("\n");
if (split != null && split.length > 0) {
for( String line : split ) {
int indexOfEquals = line.indexOf('=');
if (indexOfEquals != -1) {
String key = line.substring(0, indexOfEquals);
String value = line.substring(indexOfEquals + 1);
functionMap.put(key.trim(), value.trim());
} else {
pm.errorMessage("Ignoring expression: " + line);
}
}
}
} else {
throw new ModelsIllegalargumentException("No CQL function has been provided.", this, pm);
}
StringBuilder sB = new StringBuilder();
Set> entrySet = functionMap.entrySet();
for( Entry entry : entrySet ) {
sB.append("\n").append(entry.getKey()).append("=").append(entry.getValue());
}
String expressionString = sB.substring(1);
sample = getSample();
List names = createNameList(expressionString);
final List expressions = createExpressionList(expressionString);
SimpleFeatureType newFeatureType = createFeatureType(expressionString, originalFeatureType, names, expressions);
outVector = new DefaultFeatureCollection();
final SimpleFeatureBuilder build = new SimpleFeatureBuilder(newFeatureType);
inVector.accepts(new FeatureVisitor(){
public void visit( Feature rawFeature ) {
SimpleFeature feature = (SimpleFeature) rawFeature;
for( int i = 0; i < expressions.size(); i++ ) {
build.add(expressions.get(i).evaluate(feature));
}
SimpleFeature created = build.buildFeature(feature.getID());
((DefaultFeatureCollection) outVector).add(created);
}
}, null);
}
private SimpleFeature getSample() {
FeatureIterator iterator = inVector.features();
try {
if (!iterator.hasNext()) {
throw new ModelsRuntimeException("Input featurecollection is empty.", this.getClass().getSimpleName());
}
return iterator.next();
} finally {
iterator.close();
}
}
/**
* You cannot call this once the dialog is closed, see the okPressed method.
* @param originalFeatureType
* @param expressions
* @param names
* @return a SimpleFeatureType created based on the contents of Text
*/
private SimpleFeatureType createFeatureType( String expressionString, SimpleFeatureType originalFeatureType,
List names, List expressions ) throws SchemaException {
SimpleFeatureTypeBuilder build = new SimpleFeatureTypeBuilder();
for( int i = 0; i < names.size(); i++ ) {
String name = names.get(i);
Expression expression = expressions.get(i);
Object value = expression.evaluate(sample);
// hack because sometimes expression returns null. I think the real bug is with
// AttributeExpression
Class< ? > binding = null;
if (value == null) {
if (expression instanceof PropertyName) {
String path = ((PropertyName) expression).getPropertyName();
AttributeType attributeType = sample.getFeatureType().getType(path);
if (attributeType == null) {
throw new ModelsIllegalargumentException("Attribute type is null", this.getClass().getSimpleName(), pm);
}
binding = attributeType.getClass();
}
} else {
binding = value.getClass();
}
if (binding == null) {
throw new ModelsIllegalargumentException("Binding is null", this.getClass().getSimpleName(), pm);
}
if (Geometry.class.isAssignableFrom(binding)) {
CoordinateReferenceSystem crs;
AttributeType originalAttributeType = originalFeatureType.getType(name);
if (originalAttributeType instanceof GeometryType) {
crs = ((GeometryType) originalAttributeType).getCoordinateReferenceSystem();
} else {
crs = originalFeatureType.getCoordinateReferenceSystem();
}
build.crs(crs);
build.add(name, binding);
} else {
build.add(name, binding);
}
}
build.setName(getNewTypeName(originalFeatureType.getTypeName()));
return build.buildFeatureType();
}
/**
* You cannot call this once the dialog is closed, see the okPressed method.
* @param expressionString
*
* @return a SimpleFeatureType created based on the contents of Text
*/
private List createNameList( String expressionString ) {
List list = new ArrayList();
String definition = expressionString.replaceAll("\r", "\n").replaceAll("[\n\r][\n\r]", "\n");
for( String line : definition.split("\n") ) {
int mark = line.indexOf("=");
if (mark != -1) {
String name = line.substring(0, mark).trim();
if (list.contains(name)) {
System.out.println("Name already existing");
continue;
}
list.add(name);
}
}
return list;
}
private List createExpressionList( String expressionString ) {
List list = new ArrayList();
String definition = expressionString.replaceAll("\r", "\n").replaceAll("[\n\r][\n\r]", "\n");
for( String line : definition.split("\n") ) {
int mark = line.indexOf("=");
if (mark != -1) {
String expressionDefinition = line.substring(mark + 1).trim();
Expression expression;
try {
expression = CQL.toExpression(expressionDefinition);
} catch (CQLException e) {
throw new ModelsRuntimeException(e.toString(), this);
}
list.add(expression);
}
}
return list;
}
static int count = 0;
public String getNewTypeName( String typeName ) {
return typeName + (count++);
}
}