Java Function类代码示例

import org.opengis.filter.expression.Function; //导入依赖的package包/类
/**
 * Creates the expression.
 *
 * @param functionName the function name
 * @param argumentList the argument list
 * @return the expression
 */
/*
 * (non-Javadoc)
 * 
 * @see com.sldeditor.filter.v2.function.FunctionNameInterface#createExpression(org.opengis.filter.capability.FunctionName, java.util.List)
 */
@Override
public Expression createExpression(FunctionName functionName, List<Expression> argumentList) {
    if (functionName == null) {
        return null;
    }

    Literal fallback = null;
    Function function = functionFactory.function(functionName.getFunctionName(), argumentList,
            fallback);

    return function;
}
 

import org.opengis.filter.expression.Function; //导入依赖的package包/类
/**
 * Sets the offset in a symbolizer.
 * 
 * @param symbolizer the symbolizer.
 * @param text the text representing the offsets in the CSV form.
 */
@SuppressWarnings({"rawtypes", "unchecked"})
public static void setOffset( Symbolizer symbolizer, String text ) {
    if (text.indexOf(',') == -1) {
        return;
    }
    String[] split = text.split(",");
    if (split.length != 2) {
        return;
    }
    double xOffset = Double.parseDouble(split[0]);
    double yOffset = Double.parseDouble(split[1]);

    Expression geometry = symbolizer.getGeometry();
    if (geometry != null) {
        if (geometry instanceof FilterFunction_offset) {
            FilterFunction_offset offsetFunction = (FilterFunction_offset) geometry;
            List parameters = offsetFunction.getParameters();
            parameters.set(1, ff.literal(xOffset));
            parameters.set(2, ff.literal(yOffset));
        }
    } else {
        Function function = ff.function("offset", ff.property("the_geom"), ff.literal(xOffset), ff.literal(yOffset));
        symbolizer.setGeometry(function);
    }
}
 

import org.opengis.filter.expression.Function; //导入依赖的package包/类
public void classiferExample() {
    SimpleFeatureCollection collection = null;
    SimpleFeature feature = null;
    // classiferExample start
    FilterFactory2 ff = CommonFactoryFinder.getFilterFactory2();
    Function classify = ff.function("Quantile", ff.property("name"), ff.literal(2));
    
    Classifier groups = (Classifier) classify.evaluate(collection);
    // classiferExample end
    // classiferExample2 start
    groups.setTitle(0, "Group A");
    groups.setTitle(1, "Group B");
    // classiferExample2 end
    
    // classiferExample3 start
    // groups is a classifier with "Group A" and "Group B"
    Function sort = ff.function("classify", ff.property("name"), ff.literal(groups));
    int slot = (Integer) sort.evaluate(feature);
    
    System.out.println(groups.getTitle(slot)); // ie. "Group A"
    // classiferExample3 end
}
 

import org.opengis.filter.expression.Function; //导入依赖的package包/类
@Override
public Object visit(Function function, Object extraData) throws RuntimeException {
    helper.out = out;
    try {
        encodingFunction = true;
        boolean encoded = helper.visitFunction(function, extraData);
        encodingFunction = false;
        
        if(encoded) {
           return extraData; 
        } else {
            return super.visit(function, extraData);
        }
    } catch(IOException e) {
        throw new RuntimeException(e);
    }
}
 

import org.opengis.filter.expression.Function; //导入依赖的package包/类
/**
 * Maps a function to its native db equivalent
 * 
 * @param function
 * @return
 */
public String getFunctionName(Function function) {
    if(function instanceof FilterFunction_strLength) {
        return "char_length";
    } else if(function instanceof FilterFunction_strToLowerCase) {
        return "lower";
    } else if(function instanceof FilterFunction_strToUpperCase) {
        return "upper";
    } else if(function instanceof FilterFunction_abs ||
            function instanceof FilterFunction_abs_2 ||
            function instanceof FilterFunction_abs_3 ||
            function instanceof FilterFunction_abs_4) {
        return "abs";
    }
    return function.getName();
}
 

import org.opengis.filter.expression.Function; //导入依赖的package包/类
/**
 * Creates the expression.
 *
 * @param envVar the env var
 * @return the expression
 */
@Override
public Expression createExpression(EnvVar envVar) {
    if (envVar == null) {
        return null;
    }

    Function function = ff.function("env", ff.literal(envVar.getName()));

    return function;
}
 

import org.opengis.filter.expression.Function; //导入依赖的package包/类
/**
 * Creates the expression.
 *
 * @param functionName the function name
 * @return the expression
 */
@Override
public Expression createExpression(FunctionName functionName) {
    if (functionName == null) {
        return null;
    }

    List<Expression> parameters = null;
    Literal fallback = null;
    Function function = functionFactory.function(functionName.getFunctionName(), parameters,
            fallback);

    return function;
}
 

import org.opengis.filter.expression.Function; //导入依赖的package包/类
/**
 * Gets the expression.
 *
 * @param factory the factory
 * @return the expression
 */
public ProcessFunction getExpression(FunctionFactory factory) {
    List<Expression> overallParameterList = new ArrayList<Expression>();

    for (ProcessFunctionParameterValue value : valueList) {
        List<Expression> parameterList = new ArrayList<Expression>();
        parameterList.add(ff.literal(value.name));

        boolean setValue = true;
        if (value.optional) {
            setValue = value.included;
        }

        if (setValue) {
            if (value.objectValue != null) {
                Expression expression = value.objectValue.getExpression();
                if (expression != null) {
                    parameterList.add(expression);
                }
            }
        }

        if (setValue) {
            Function function = factory.function(PARAMETER, parameterList, null);

            overallParameterList.add(function);
        }
    }

    if (this.selectedFunction.getFunctionName() == null) {
        return null;
    }
    Function processFunction = factory.function(this.selectedFunction.getFunctionName(),
            overallParameterList, null);

    return (ProcessFunction) processFunction;
}
 

import org.opengis.filter.expression.Function; //导入依赖的package包/类
public ClassifiedStyleCreator() {
Set<Function> funcs = CommonFactoryFinder.getFunctions(GeoTools
	.getDefaultHints());
ArrayList<String> fNames = new ArrayList<String>();
for (Function func : funcs) {
    if (func instanceof ClassificationFunction) {
	classifiers.add(func);
	fNames.add(func.getName());
    }
}
setPalette(DEFAULT_PALETTE);
setNumberOfClasses(DEFAULT_NUMBER_OF_CLASSES);
setClassifier(DEFAULT_CLASSIFIER);
   }
 

import org.opengis.filter.expression.Function; //导入依赖的package包/类
public void setClassifier(String name) {
for (Function f : classifiers) {
    if (f.getName().equalsIgnoreCase(name)) {
	setClassifier(f);
	return;
    }
}
   }
 

import org.opengis.filter.expression.Function; //导入依赖的package包/类
public List<String> getFunctionNames() {
ArrayList<String> ret = new ArrayList<String>();

for (Function f : classifiers) {
    ret.add(f.getName());

}
return ret;
   }
 

import org.opengis.filter.expression.Function; //导入依赖的package包/类
/**
 * Ritorna una function usando il nome
 */
@Override
public Function function(Name name, List<Expression> args, Literal fallback) {
	if( SnapFunction.NAME.getFunctionName().equals(name)){
           return new SnapFunction( args, fallback );
       }
	else if( Fluxomizer.NAME.getFunctionName().equals(name) ){
		return new Fluxomizer(args, fallback);
	}
       return null; // we do not implement that function
}
 

import org.opengis.filter.expression.Function; //导入依赖的package包/类
public Function function(Name name, List<Expression> args, Literal fallback) {
    if(new NameImpl("first").equals(name)){
        return new AbstractFunction( FIRST, args, fallback ){
            public Geometry evaluate(Object object) {
                Geometry geom = eval(object, 0, Geometry.class );
                Coordinate coordinate = geom.getCoordinate();
                return geom.getFactory().createPoint(coordinate);
            }
        };
    }
    return null; // we do not implement that function
}
 

import org.opengis.filter.expression.Function; //导入依赖的package包/类
public void classiferQuantile() {
    SimpleFeatureCollection collection = null;
    SimpleFeature feature = null;
    // classiferQuantile start
    FilterFactory2 ff = CommonFactoryFinder.getFilterFactory2();
    Function classify = ff.function("Quantile", ff.property("zone"), ff.literal(2));
    
    // Zones assigned by a municipal board do not have an intrinsic numerical
    // meaning making them suitable for display using:
    // - qualitative palette where each zone would have the same visual impact
    Classifier groups = (Classifier) classify.evaluate(collection);
    // classiferQuantile end
}
 

import org.opengis.filter.expression.Function; //导入依赖的package包/类
public void classiferEqualInterval() {
    SimpleFeatureCollection collection = null;
    SimpleFeature feature = null;
    // classiferEqualInterval start
    FilterFactory2 ff = CommonFactoryFinder.getFilterFactory2();
    Function classify = ff.function("EqualInterval", ff.property("height"), ff.literal(5));
    
    // this will create a nice smooth series of intervals suitable for presentation
    // with:
    // - sequential color palette to make each height blend smoothly into the next
    // - diverging color palettes if you want to make higher and lower areas stand out more
    Classifier height = (Classifier) classify.evaluate(collection);
    // classiferEqualInterval end
}