git-svn-id: https://svn.d4science.research-infrastructures.eu/gcube/trunk/data-analysis/wps@150390 82a268e6-3cf1-43bd-a215-b396298e98cf
parent
b03240b828
commit
7ab1d6eeef
@ -0,0 +1,162 @@
|
||||
package org.gcube.data.analysis.wps;
|
||||
|
||||
import java.io.ByteArrayInputStream;
|
||||
import java.io.IOException;
|
||||
import java.io.InputStream;
|
||||
import java.io.OutputStream;
|
||||
import java.io.PrintWriter;
|
||||
import java.util.UUID;
|
||||
|
||||
import javax.servlet.ServletConfig;
|
||||
import javax.servlet.ServletException;
|
||||
import javax.servlet.http.HttpServlet;
|
||||
import javax.servlet.http.HttpServletRequest;
|
||||
import javax.servlet.http.HttpServletResponse;
|
||||
|
||||
import org.apache.commons.lang.StringUtils;
|
||||
import org.n52.wps.commons.XMLUtil;
|
||||
import org.n52.wps.server.database.DatabaseFactory;
|
||||
import org.n52.wps.server.database.IDatabase;
|
||||
import org.slf4j.Logger;
|
||||
import org.slf4j.LoggerFactory;
|
||||
|
||||
public class CancelComputation extends HttpServlet {
|
||||
|
||||
private final static Logger LOGGER = LoggerFactory.getLogger(CancelComputation.class);
|
||||
private static final long serialVersionUID = -268198171054599696L;
|
||||
// This is required for URL generation for response documents.
|
||||
public final static String SERVLET_PATH = "RetrieveResultServlet";
|
||||
// in future parameterize
|
||||
//private final boolean indentXML = false;
|
||||
|
||||
private final int uuid_length = 36;
|
||||
|
||||
@Override
|
||||
public void init(ServletConfig config) throws ServletException {
|
||||
super.init(config);
|
||||
}
|
||||
|
||||
public static String empty = "<wps:ExecuteResponse service=\"WPS\" " +
|
||||
"serviceInstance=\"\" statusLocation=\"\" version=\"1.0.0\" xml:lang=\"en-US\" xsi:schemaLocation=\"http://www.opengis.net/wps/1.0.0 http://schemas.opengis.net/wps/1.0.0/wpsExecute_response.xsd\" " +
|
||||
"xmlns:ows=\"http://www.opengis.net/ows/1.1\" xmlns:wps=\"http://www.opengis.net/wps/1.0.0\" " +
|
||||
"xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\"> " +
|
||||
"<wps:Process wps:processVersion=\"1.1.0\"/> " +
|
||||
"</wps:ExecuteResponse>";
|
||||
@Override
|
||||
protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
|
||||
|
||||
// id of result to retrieve.
|
||||
String id = request.getParameter("id");
|
||||
|
||||
LOGGER.debug("CANCEL COMPUTATION -> RETRIEVING ID " + id);
|
||||
if (StringUtils.isEmpty(id)) {
|
||||
errorResponse("id parameter missing", response);
|
||||
} else {
|
||||
LOGGER.debug("CANCEL COMPUTATION -> ID RETRIEVED " + id);
|
||||
if (!isIDValid(id)) {
|
||||
errorResponse("id parameter not valid", response);
|
||||
}
|
||||
LOGGER.debug("CANCEL COMPUTATION -> ID IS VALID " + id);
|
||||
IDatabase db = DatabaseFactory.getDatabase();
|
||||
long len = db.getContentLengthForStoreResponse(id);
|
||||
LOGGER.debug("CANCEL COMPUTATION -> INITIAL ID RESPONSE LENGTH " + len);
|
||||
|
||||
try {
|
||||
LOGGER.debug("CANCEL COMPUTATION -> DELETING ID " + id);
|
||||
|
||||
try {
|
||||
// String empty = "";
|
||||
InputStream stream = new ByteArrayInputStream(empty.getBytes("UTF-8"));
|
||||
db.updateResponse(id, stream);
|
||||
stream.close();
|
||||
} catch (Exception e) {
|
||||
LOGGER.error("error reading th einput stream",e);
|
||||
}
|
||||
LOGGER.debug("CANCEL COMPUTATION -> ID DELETED " + id);
|
||||
len = db.getContentLengthForStoreResponse(id);
|
||||
LOGGER.debug("CANCEL COMPUTATION -> ID RESPONSE LENGTH " + len);
|
||||
} catch (Exception e) {
|
||||
LOGGER.error("error in do get",e);
|
||||
} finally {
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
protected void errorResponse(String error, HttpServletResponse response) throws IOException {
|
||||
response.setContentType("text/html");
|
||||
response.setStatus(HttpServletResponse.SC_BAD_REQUEST);
|
||||
PrintWriter writer = response.getWriter();
|
||||
writer.write("<html><title>Error</title><body>" + error + "</body></html>");
|
||||
writer.flush();
|
||||
LOGGER.warn("Error processing response: " + error);
|
||||
}
|
||||
|
||||
protected void copyResponseStream(InputStream inputStream, OutputStream outputStream, String id, long contentLength) throws IOException {
|
||||
long contentWritten = 0;
|
||||
try {
|
||||
byte[] buffer = new byte[8192];
|
||||
int bufferRead;
|
||||
while ((bufferRead = inputStream.read(buffer)) != -1) {
|
||||
outputStream.write(buffer, 0, bufferRead);
|
||||
contentWritten += bufferRead;
|
||||
}
|
||||
} catch (IOException e) {
|
||||
String exceptionMessage = contentLength > -1 ? String.format("Error writing response to output stream for id %s, %d of %d bytes written", id, contentWritten, contentLength) : String.format("Error writing response to output stream for id %s, %d bytes written", id, contentWritten);
|
||||
throw new IOException(exceptionMessage, e);
|
||||
}
|
||||
LOGGER.info("{} bytes written in response to id {}", contentWritten, id);
|
||||
}
|
||||
|
||||
protected void copyResponseAsXML(InputStream inputStream, OutputStream outputStream, boolean indent, String id) throws IOException {
|
||||
try {
|
||||
XMLUtil.copyXML(inputStream, outputStream, indent);
|
||||
} catch (IOException e) {
|
||||
throw new IOException("Error writing XML response for id " + id, e);
|
||||
}
|
||||
}
|
||||
|
||||
public static Throwable getRootCause(Throwable t) {
|
||||
return t.getCause() == null ? t : getRootCause(t.getCause());
|
||||
}
|
||||
|
||||
public boolean isIDValid(String id) {
|
||||
|
||||
if (id.length() <= uuid_length) {
|
||||
|
||||
try {
|
||||
UUID checkUUID = UUID.fromString(id);
|
||||
|
||||
if (checkUUID.toString().equals(id)) {
|
||||
return true;
|
||||
} else {
|
||||
return false;
|
||||
}
|
||||
} catch (Exception e) {
|
||||
return false;
|
||||
}
|
||||
|
||||
} else {
|
||||
|
||||
String uuidPartOne = id.substring(0, uuid_length);
|
||||
String uuidPartTwo = id.substring(id.length() - uuid_length, id.length());
|
||||
|
||||
return isUUIDValid(uuidPartOne) && isUUIDValid(uuidPartTwo);
|
||||
}
|
||||
}
|
||||
|
||||
public boolean isUUIDValid(String uuid) {
|
||||
|
||||
// the following can be used to check whether the id is a valid UUID
|
||||
try {
|
||||
UUID checkUUID = UUID.fromString(uuid);
|
||||
|
||||
if (checkUUID.toString().equals(uuid)) {
|
||||
return true;
|
||||
} else {
|
||||
return false;
|
||||
}
|
||||
} catch (Exception e) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,31 @@
|
||||
package org.gcube.data.analysis.wps;
|
||||
|
||||
import java.io.InputStream;
|
||||
|
||||
import org.n52.wps.server.ExceptionReport;
|
||||
import org.n52.wps.server.request.ExecuteRequest;
|
||||
import org.n52.wps.server.response.ExecuteResponseBuilder;
|
||||
import org.n52.wps.server.response.Response;
|
||||
|
||||
public class ExecuteResponse extends Response {
|
||||
|
||||
private ExecuteResponseBuilder builder;
|
||||
|
||||
public ExecuteResponse(ExecuteRequest request) throws ExceptionReport{
|
||||
super(request);
|
||||
this.builder = ((ExecuteRequest)this.request).getExecuteResponseBuilder();
|
||||
}
|
||||
|
||||
@Override
|
||||
public InputStream getAsStream() throws ExceptionReport{
|
||||
return this.builder.getAsStream();
|
||||
}
|
||||
|
||||
public ExecuteResponseBuilder getExecuteResponseBuilder(){
|
||||
return builder;
|
||||
}
|
||||
|
||||
public String getMimeType(){
|
||||
return builder.getMimeType();
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,132 @@
|
||||
package org.gcube.data.analysis.wps;
|
||||
|
||||
import java.io.InputStream;
|
||||
import java.util.HashMap;
|
||||
import java.util.LinkedHashMap;
|
||||
import java.util.List;
|
||||
import java.util.Map;
|
||||
import java.util.Set;
|
||||
|
||||
import org.apache.commons.io.IOUtils;
|
||||
import org.gcube.common.scope.api.ScopeProvider;
|
||||
import org.gcube.data.analysis.wps.repository.GcubeAlgorithmRepository;
|
||||
import org.gcube.dataanalysis.ecoengine.processing.factories.ProcessorsFactory;
|
||||
import org.gcube.dataanalysis.wps.statisticalmanager.synchserver.infrastructure.InfrastructureDialoguer;
|
||||
import org.gcube.dataanalysis.wps.statisticalmanager.synchserver.mapping.ConfigurationManager;
|
||||
import org.gcube.dataanalysis.wps.statisticalmanager.synchserver.mapping.TokenManager;
|
||||
import org.n52.wps.commons.WPSConfig;
|
||||
import org.slf4j.Logger;
|
||||
import org.slf4j.LoggerFactory;
|
||||
|
||||
public class GetCapabilitiesBuilder {
|
||||
|
||||
public static String processString = "<wps:Process wps:processVersion=\"1.1.0\">\n\t<ows:Identifier>#CLASS#</ows:Identifier>\n\t<ows:Title>#TITLE#</ows:Title>\n</wps:Process>";
|
||||
|
||||
private static final Logger LOGGER= LoggerFactory.getLogger(GetCapabilitiesBuilder.class);
|
||||
|
||||
public String getClassification(String algorithmName, ConfigurationManager configManager) throws Exception{
|
||||
//get algorithms classification:
|
||||
LOGGER.debug("Searching for a classification of "+algorithmName);
|
||||
HashMap<String, List<String>> algorithmsClassification = ProcessorsFactory.getAllFeaturesUser(configManager.getConfig());
|
||||
String rightClassification = "Others";
|
||||
for (String classification:algorithmsClassification.keySet()){
|
||||
List<String> algorithms = algorithmsClassification.get(classification);
|
||||
if (algorithms.contains(algorithmName)){
|
||||
LOGGER.debug("Found classification"+classification);
|
||||
return classification;
|
||||
}
|
||||
}
|
||||
LOGGER.debug("No classification found for "+algorithmName);
|
||||
return rightClassification;
|
||||
}
|
||||
|
||||
public String buildGetCapabilities(Map<String, String[]> parameters) throws Exception {
|
||||
|
||||
LinkedHashMap<String, Object> basicInputs = new LinkedHashMap<String, Object>();
|
||||
//DONE get scope and username from SmartGears to build the get capabilities
|
||||
/* OLD CODE
|
||||
if (parameters != null) {
|
||||
if (parameters.get(ConfigurationManager.scopeParameter) != null)
|
||||
basicInputs.put(ConfigurationManager.scopeParameter, parameters.get(ConfigurationManager.scopeParameter)[0]);
|
||||
if (parameters.get(ConfigurationManager.usernameParameter) != null)
|
||||
basicInputs.put(ConfigurationManager.usernameParameter, parameters.get(ConfigurationManager.usernameParameter)[0]);
|
||||
} else {// case for testing purposes only
|
||||
if (AbstractEcologicalEngineMapper.simulationMode){
|
||||
basicInputs.put(ConfigurationManager.scopeParameter, ConfigurationManager.defaultScope);
|
||||
basicInputs.put(ConfigurationManager.usernameParameter, ConfigurationManager.defaultUsername);
|
||||
}
|
||||
}
|
||||
*/
|
||||
ConfigurationManager configManager = new ConfigurationManager();
|
||||
TokenManager tokenm = new TokenManager();
|
||||
tokenm.getCredentials();
|
||||
String scope = tokenm.getScope();
|
||||
String username = tokenm.getUserName();
|
||||
String token = tokenm.getToken();
|
||||
basicInputs.put(ConfigurationManager.scopeParameter, scope);
|
||||
basicInputs.put(ConfigurationManager.usernameParameter, username);
|
||||
basicInputs.put(ConfigurationManager.tokenParameter, token);
|
||||
|
||||
configManager.configAlgorithmEnvironment(basicInputs);
|
||||
LOGGER.debug("Initializing Capabilities Skeleton in scope " + configManager.getScope() + " with user " + configManager.getUsername());
|
||||
InputStream is = this.getClass().getClassLoader().getResourceAsStream("templates/wpsCapabilitiesSkeleton.xml");
|
||||
String stringTemplate = IOUtils.toString(is, "UTF-8");
|
||||
|
||||
//TODO: GET HOSTNAME AND PORT from container
|
||||
String host = WPSConfig.getInstance().getWPSConfig().getServer().getHostname();
|
||||
String port = WPSConfig.getInstance().getWPSConfig().getServer().getHostport();
|
||||
stringTemplate = stringTemplate.replace("#HOST#", host).replace("#PORT#", port);
|
||||
|
||||
LOGGER.debug("Host: " + host + " Port: " + port);
|
||||
|
||||
LinkedHashMap<String, String> allalgorithms = new LinkedHashMap<String, String>();
|
||||
/*
|
||||
String packageS = "org.gcube.dataanalysis.wps.statisticalmanager.synchserver.mappedclasses";
|
||||
List<Class<?>> classes = null;
|
||||
try{
|
||||
LOGGER.debug("Taking classes from /classes");
|
||||
classes = GetCapabilitiesChecker.find(packageS);
|
||||
}catch(Exception e){
|
||||
LOGGER.debug("Taking classes from the Jar");
|
||||
classes=GetCapabilitiesChecker.getClassesInSamePackageFromJar(packageS);
|
||||
}*/
|
||||
|
||||
LOGGER.info("using classloader class {} ",Thread.currentThread().getContextClassLoader().getClass().getSimpleName());
|
||||
|
||||
|
||||
Set<Class<?>> algorithmsClass = GcubeAlgorithmRepository.getAllAlgorithms();
|
||||
|
||||
LOGGER.info("class found with annotation Algorithm are {}",algorithmsClass.size());
|
||||
|
||||
for (Class<?> classfind : algorithmsClass) {
|
||||
org.n52.wps.algorithm.annotation.Algorithm algorithmInfo = classfind.getAnnotation(org.n52.wps.algorithm.annotation.Algorithm.class);
|
||||
if (algorithmInfo != null) {
|
||||
LOGGER.debug("Retrieving local declared Algorithm: " + algorithmInfo.title());
|
||||
allalgorithms.put(algorithmInfo.title(), classfind.getName());
|
||||
}
|
||||
}
|
||||
|
||||
LOGGER.debug("Getting algorithms from the infrastructure");
|
||||
InfrastructureDialoguer dialoguer = new InfrastructureDialoguer(configManager.getScope());
|
||||
List<String> algorithmsInScope = dialoguer.getAlgorithmsInScope();
|
||||
LOGGER.debug("Found {} algorithms in scope {} ",algorithmsInScope.size() ,ScopeProvider.instance.get());
|
||||
StringBuffer capabilities = new StringBuffer();
|
||||
|
||||
for (String algorithmInScope : algorithmsInScope) {
|
||||
String classAlgorithm = allalgorithms.get(algorithmInScope);
|
||||
if (classAlgorithm != null) {
|
||||
LOGGER.debug("Approving " + classAlgorithm + " to capabilities ");
|
||||
String algorithmTitle = getClassification(algorithmInScope, configManager)+":"+algorithmInScope;
|
||||
// String algorithmTitle = algorithmInScope;
|
||||
capabilities.append(processString.replace("#TITLE#", algorithmTitle).replace("#CLASS#", classAlgorithm));
|
||||
}
|
||||
}
|
||||
|
||||
stringTemplate = stringTemplate.replace("#PROCESSES#", capabilities.toString());
|
||||
LOGGER.debug("Get capabilities built");
|
||||
return stringTemplate;
|
||||
}
|
||||
|
||||
|
||||
|
||||
}
|
||||
@ -0,0 +1,129 @@
|
||||
package org.gcube.data.analysis.wps.repository;
|
||||
|
||||
import static java.nio.file.StandardWatchEventKinds.ENTRY_CREATE;
|
||||
import static java.nio.file.StandardWatchEventKinds.OVERFLOW;
|
||||
|
||||
import java.io.IOException;
|
||||
import java.lang.reflect.Method;
|
||||
import java.net.URL;
|
||||
import java.net.URLClassLoader;
|
||||
import java.nio.file.FileSystems;
|
||||
import java.nio.file.Path;
|
||||
import java.nio.file.Paths;
|
||||
import java.nio.file.WatchEvent;
|
||||
import java.nio.file.WatchKey;
|
||||
import java.nio.file.WatchService;
|
||||
|
||||
import org.slf4j.Logger;
|
||||
import org.slf4j.LoggerFactory;
|
||||
|
||||
public final class AlgorithmUpdater {
|
||||
|
||||
private static final Logger log = LoggerFactory.getLogger(AlgorithmUpdater.class);
|
||||
|
||||
private String algorithmDirectory;
|
||||
|
||||
private boolean mustUpdate = false;
|
||||
|
||||
private WatcherThread watcherThread = null;
|
||||
|
||||
public AlgorithmUpdater(String algorithmDirectory) {
|
||||
super();
|
||||
this.algorithmDirectory = algorithmDirectory;
|
||||
}
|
||||
|
||||
protected synchronized boolean mustUpdate(){
|
||||
return mustUpdate;
|
||||
}
|
||||
|
||||
protected synchronized void reset(){
|
||||
mustUpdate = false;
|
||||
}
|
||||
|
||||
public boolean isStarted(){
|
||||
return watcherThread!=null;
|
||||
}
|
||||
|
||||
protected void startWhatcher(){
|
||||
watcherThread = new WatcherThread(Thread.currentThread().getContextClassLoader(), algorithmDirectory);
|
||||
watcherThread.start();
|
||||
}
|
||||
|
||||
private class WatcherThread extends Thread {
|
||||
|
||||
private WatchService watcher;
|
||||
private ClassLoader loader;
|
||||
private Path dir;
|
||||
|
||||
public WatcherThread(ClassLoader loader, String algorithmDirectory) {
|
||||
super();
|
||||
try {
|
||||
watcher = FileSystems.getDefault().newWatchService();
|
||||
this.loader = loader;
|
||||
//TODO: change with something from configuration
|
||||
dir = Paths.get(algorithmDirectory);
|
||||
dir.register(watcher, ENTRY_CREATE);
|
||||
} catch (IOException e) {
|
||||
throw new RuntimeException(e);
|
||||
}
|
||||
}
|
||||
|
||||
@SuppressWarnings("unchecked")
|
||||
public void run(){
|
||||
for (;;) {
|
||||
|
||||
// wait for key to be signaled
|
||||
WatchKey key;
|
||||
try {
|
||||
key = watcher.take();
|
||||
} catch (InterruptedException x) {
|
||||
return;
|
||||
}
|
||||
|
||||
for (WatchEvent<?> event: key.pollEvents()) {
|
||||
WatchEvent.Kind<?> kind = event.kind();
|
||||
|
||||
// This key is registered only
|
||||
// for ENTRY_CREATE events,
|
||||
// but an OVERFLOW event can
|
||||
// occur regardless if events
|
||||
// are lost or discarded.
|
||||
if (kind == OVERFLOW) {
|
||||
continue;
|
||||
}
|
||||
|
||||
// The filename is the
|
||||
// context of the event.
|
||||
WatchEvent<Path> ev = (WatchEvent<Path>)event;
|
||||
Path filename = ev.context();
|
||||
if (filename.toString().endsWith(".jar")){
|
||||
try{
|
||||
final Class<URLClassLoader> sysclass = URLClassLoader.class;
|
||||
// TODO some kind of a hack. Need to invent better solution.
|
||||
final Method method = sysclass.getDeclaredMethod("addURL", new Class[] { URL.class });
|
||||
method.setAccessible(true);
|
||||
method.invoke(loader, new URL[] { dir.resolve(filename).toFile().toURI().toURL() });
|
||||
log.info("filename added is {} in loader {}",filename, loader.getClass().getName());
|
||||
mustUpdate = true;
|
||||
}catch(Exception e){
|
||||
log.error("filename {} cannot be added to classpath",e,filename);
|
||||
}
|
||||
} else log.info("filename {} is not a jar",filename);
|
||||
|
||||
}
|
||||
|
||||
boolean valid = key.reset();
|
||||
if (!valid) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
protected void shutdown(){
|
||||
if (isStarted()){
|
||||
//TODO : kill the watcherThread
|
||||
watcherThread = null;
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,120 @@
|
||||
package org.gcube.data.analysis.wps.repository;
|
||||
|
||||
import java.net.URLClassLoader;
|
||||
import java.util.ArrayList;
|
||||
import java.util.Collection;
|
||||
import java.util.Set;
|
||||
|
||||
import net.opengis.wps.x100.ProcessDescriptionType;
|
||||
|
||||
import org.n52.wps.algorithm.annotation.Algorithm;
|
||||
import org.n52.wps.server.IAlgorithm;
|
||||
import org.n52.wps.server.IAlgorithmRepository;
|
||||
import org.reflections.Reflections;
|
||||
import org.reflections.util.ConfigurationBuilder;
|
||||
import org.reflections.util.FilterBuilder;
|
||||
import org.slf4j.Logger;
|
||||
import org.slf4j.LoggerFactory;
|
||||
|
||||
public class GcubeAlgorithmRepository implements IAlgorithmRepository {
|
||||
|
||||
private static Logger log = LoggerFactory.getLogger(GcubeAlgorithmRepository.class);
|
||||
|
||||
private static AlgorithmUpdater updater = null;
|
||||
|
||||
private static Reflections reflection;
|
||||
|
||||
private static final String PACKAGE_TO_FIND = "org.gcube.dataanalysis.wps.statisticalmanager.synchserver.mappedclasses";
|
||||
|
||||
public GcubeAlgorithmRepository(){
|
||||
log.info("gcube algorithm repository started");
|
||||
if (updater==null) throw new RuntimeException("GcubeAlgorithmRepository cannot be initialized: updater is null");
|
||||
updateRepository();
|
||||
updater.startWhatcher();
|
||||
}
|
||||
|
||||
public ProcessDescriptionType getProcessDescription(String identifier){
|
||||
updateRepository();
|
||||
log.info("getProcessDescription with identifier {} ",identifier);
|
||||
try{
|
||||
Set<Class<?>> classes = reflection.getTypesAnnotatedWith(Algorithm.class);
|
||||
for (Class<?> _class: classes){
|
||||
if (_class.getAnnotation(Algorithm.class).identifier().equals(identifier)){
|
||||
return ((IAlgorithm)_class.newInstance()).getDescription();
|
||||
}
|
||||
}
|
||||
}catch(Exception e){}
|
||||
throw new RuntimeException(String.format("Algorithm with process id %s not found", identifier));
|
||||
}
|
||||
|
||||
public boolean containsAlgorithm(String identifier) {
|
||||
updateRepository();
|
||||
log.info("containsAlgorithm with identifier {} ",identifier);
|
||||
Set<Class<?>> classes = reflection.getTypesAnnotatedWith(Algorithm.class);
|
||||
for (Class<?> _class: classes){
|
||||
if (_class.getAnnotation(Algorithm.class).identifier().equals(identifier)){
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
public IAlgorithm getAlgorithm(String identifier){
|
||||
updateRepository();
|
||||
log.info("getAlgorithm with identifier {} ",identifier);
|
||||
try{
|
||||
Set<Class<?>> classes = reflection.getTypesAnnotatedWith(Algorithm.class);
|
||||
for (Class<?> _class: classes){
|
||||
if (_class.getAnnotation(Algorithm.class).identifier().equals(identifier)){
|
||||
if (IAlgorithm.class.isAssignableFrom(_class)){
|
||||
return (IAlgorithm)_class.newInstance();
|
||||
} else {
|
||||
log.warn("found algorothm class {} is no assignable from {}",_class.getName(), IAlgorithm.class.getName());
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}catch(Exception e){}
|
||||
throw new RuntimeException(String.format("Algorithm with id %s not found", identifier));
|
||||
}
|
||||
|
||||
public static Set<Class<?>> getAllAlgorithms() {
|
||||
updateRepository();
|
||||
return reflection.getTypesAnnotatedWith(Algorithm.class);
|
||||
}
|
||||
|
||||
private static synchronized void updateRepository(){
|
||||
if (reflection==null || updater.mustUpdate()){
|
||||
updater.reset();
|
||||
log.info("update time passed, updating repository");
|
||||
ConfigurationBuilder confBuilder = new ConfigurationBuilder()
|
||||
.filterInputsBy(new FilterBuilder().include(FilterBuilder.prefix(PACKAGE_TO_FIND)))
|
||||
.setUrls(((URLClassLoader)Thread.currentThread().getContextClassLoader()).getURLs());
|
||||
reflection = new Reflections(confBuilder);
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public Collection<String> getAlgorithmNames() {
|
||||
updateRepository();
|
||||
Collection<String> toReturn = new ArrayList<String>();
|
||||
Set<Class<?>> classes = reflection.getTypesAnnotatedWith(Algorithm.class);
|
||||
for (Class<?> _class: classes){
|
||||
toReturn.add(_class.getAnnotation(Algorithm.class).title());
|
||||
}
|
||||
return toReturn;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void shutdown() {
|
||||
reflection = null;
|
||||
}
|
||||
|
||||
public static boolean setUpdater(AlgorithmUpdater au){
|
||||
if (updater==null){
|
||||
updater = au;
|
||||
return true;
|
||||
} else return false;
|
||||
}
|
||||
|
||||
}
|
||||
@ -1,23 +0,0 @@
|
||||
Copyright (c) 2007-2009 Marijn Haverbeke
|
||||
|
||||
This software is provided 'as-is', without any express or implied
|
||||
warranty. In no event will the authors be held liable for any
|
||||
damages arising from the use of this software.
|
||||
|
||||
Permission is granted to anyone to use this software for any
|
||||
purpose, including commercial applications, and to alter it and
|
||||
redistribute it freely, subject to the following restrictions:
|
||||
|
||||
1. The origin of this software must not be misrepresented; you must
|
||||
not claim that you wrote the original software. If you use this
|
||||
software in a product, an acknowledgment in the product
|
||||
documentation would be appreciated but is not required.
|
||||
|
||||
2. Altered source versions must be plainly marked as such, and must
|
||||
not be misrepresented as being the original software.
|
||||
|
||||
3. This notice may not be removed or altered from any source
|
||||
distribution.
|
||||
|
||||
Marijn Haverbeke
|
||||
marijnh at gmail
|
||||
@ -1,402 +0,0 @@
|
||||
/* CodeMirror main module
|
||||
*
|
||||
* Implements the CodeMirror constructor and prototype, which take care
|
||||
* of initializing the editor frame, and providing the outside interface.
|
||||
*/
|
||||
|
||||
// The CodeMirrorConfig object is used to specify a default
|
||||
// configuration. If you specify such an object before loading this
|
||||
// file, the values you put into it will override the defaults given
|
||||
// below. You can also assign to it after loading.
|
||||
var CodeMirrorConfig = window.CodeMirrorConfig || {};
|
||||
|
||||
var CodeMirror = (function(){
|
||||
function setDefaults(object, defaults) {
|
||||
for (var option in defaults) {
|
||||
if (!object.hasOwnProperty(option))
|
||||
object[option] = defaults[option];
|
||||
}
|
||||
}
|
||||
function forEach(array, action) {
|
||||
for (var i = 0; i < array.length; i++)
|
||||
action(array[i]);
|
||||
}
|
||||
|
||||
// These default options can be overridden by passing a set of
|
||||
// options to a specific CodeMirror constructor. See manual.html for
|
||||
// their meaning.
|
||||
setDefaults(CodeMirrorConfig, {
|
||||
stylesheet: "",
|
||||
path: "",
|
||||
parserfile: [],
|
||||
basefiles: ["util.js", "stringstream.js", "select.js", "undo.js", "editor.js", "tokenize.js"],
|
||||
iframeClass: null,
|
||||
passDelay: 200,
|
||||
passTime: 50,
|
||||
lineNumberDelay: 200,
|
||||
lineNumberTime: 50,
|
||||
continuousScanning: false,
|
||||
saveFunction: null,
|
||||
onChange: null,
|
||||
undoDepth: 50,
|
||||
undoDelay: 800,
|
||||
disableSpellcheck: true,
|
||||
textWrapping: true,
|
||||
readOnly: false,
|
||||
width: "",
|
||||
height: "300px",
|
||||
autoMatchParens: false,
|
||||
parserConfig: null,
|
||||
tabMode: "indent", // or "spaces", "default", "shift"
|
||||
reindentOnLoad: false,
|
||||
activeTokens: null,
|
||||
cursorActivity: null,
|
||||
lineNumbers: false,
|
||||
indentUnit: 2
|
||||
});
|
||||
|
||||
function addLineNumberDiv(container) {
|
||||
var nums = document.createElement("DIV"),
|
||||
scroller = document.createElement("DIV");
|
||||
nums.style.position = "absolute";
|
||||
nums.style.height = "100%";
|
||||
if (nums.style.setExpression) {
|
||||
try {nums.style.setExpression("height", "this.previousSibling.offsetHeight + 'px'");}
|
||||
catch(e) {} // Seems to throw 'Not Implemented' on some IE8 versions
|
||||
}
|
||||
nums.style.top = "0px";
|
||||
nums.style.overflow = "hidden";
|
||||
container.appendChild(nums);
|
||||
scroller.className = "CodeMirror-line-numbers";
|
||||
nums.appendChild(scroller);
|
||||
return nums;
|
||||
}
|
||||
|
||||
function CodeMirror(place, options) {
|
||||
// Backward compatibility for deprecated options.
|
||||
if (options.dumbTabs) options.tabMode = "spaces";
|
||||
else if (options.normalTab) options.tabMode = "default";
|
||||
|
||||
// Use passed options, if any, to override defaults.
|
||||
this.options = options = options || {};
|
||||
setDefaults(options, CodeMirrorConfig);
|
||||
|
||||
var frame = this.frame = document.createElement("IFRAME");
|
||||
if (options.iframeClass) frame.className = options.iframeClass;
|
||||
frame.frameBorder = 0;
|
||||
frame.src = "javascript:false;";
|
||||
frame.style.border = "0";
|
||||
frame.style.width = '100%';
|
||||
frame.style.height = '100%';
|
||||
// display: block occasionally suppresses some Firefox bugs, so we
|
||||
// always add it, redundant as it sounds.
|
||||
frame.style.display = "block";
|
||||
|
||||
var div = this.wrapping = document.createElement("DIV");
|
||||
div.style.position = "relative";
|
||||
div.className = "CodeMirror-wrapping";
|
||||
div.style.width = options.width;
|
||||
div.style.height = options.height;
|
||||
|
||||
if (place.appendChild) place.appendChild(div);
|
||||
else place(div);
|
||||
div.appendChild(frame);
|
||||
if (options.lineNumbers) this.lineNumbers = addLineNumberDiv(div);
|
||||
|
||||
// Link back to this object, so that the editor can fetch options
|
||||
// and add a reference to itself.
|
||||
frame.CodeMirror = this;
|
||||
this.win = frame.contentWindow;
|
||||
|
||||
if (typeof options.parserfile == "string")
|
||||
options.parserfile = [options.parserfile];
|
||||
if (typeof options.stylesheet == "string")
|
||||
options.stylesheet = [options.stylesheet];
|
||||
|
||||
var html = ["<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.0 Transitional//EN\" \"http://www.w3.org/TR/html4/loose.dtd\"><html><head>"];
|
||||
// Hack to work around a bunch of IE8-specific problems.
|
||||
html.push("<meta http-equiv=\"X-UA-Compatible\" content=\"IE=EmulateIE7\"/>");
|
||||
forEach(options.stylesheet, function(file) {
|
||||
html.push("<link rel=\"stylesheet\" type=\"text/css\" href=\"" + file + "\"/>");
|
||||
});
|
||||
forEach(options.basefiles.concat(options.parserfile), function(file) {
|
||||
html.push("<script type=\"text/javascript\" src=\"" + options.path + file + "\"><" + "/script>");
|
||||
});
|
||||
html.push("</head><body style=\"border-width: 0;\" class=\"editbox\" spellcheck=\"" +
|
||||
(options.disableSpellcheck ? "false" : "true") + "\"></body></html>");
|
||||
|
||||
var doc = this.win.document;
|
||||
doc.open();
|
||||
doc.write(html.join(""));
|
||||
doc.close();
|
||||
}
|
||||
|
||||
CodeMirror.prototype = {
|
||||
init: function() {
|
||||
if (this.options.initCallback) this.options.initCallback(this);
|
||||
if (this.options.lineNumbers) this.activateLineNumbers();
|
||||
if (this.options.reindentOnLoad) this.reindent();
|
||||
},
|
||||
|
||||
getCode: function() {return this.editor.getCode();},
|
||||
setCode: function(code) {this.editor.importCode(code);},
|
||||
selection: function() {this.focusIfIE(); return this.editor.selectedText();},
|
||||
reindent: function() {this.editor.reindent();},
|
||||
reindentSelection: function() {this.focusIfIE(); this.editor.reindentSelection(null);},
|
||||
|
||||
focusIfIE: function() {
|
||||
// in IE, a lot of selection-related functionality only works when the frame is focused
|
||||
if (this.win.select.ie_selection) this.focus();
|
||||
},
|
||||
focus: function() {
|
||||
this.win.focus();
|
||||
if (this.editor.selectionSnapshot) // IE hack
|
||||
this.win.select.setBookmark(this.win.document.body, this.editor.selectionSnapshot);
|
||||
},
|
||||
replaceSelection: function(text) {
|
||||
this.focus();
|
||||
this.editor.replaceSelection(text);
|
||||
return true;
|
||||
},
|
||||
replaceChars: function(text, start, end) {
|
||||
this.editor.replaceChars(text, start, end);
|
||||
},
|
||||
getSearchCursor: function(string, fromCursor, caseFold) {
|
||||
return this.editor.getSearchCursor(string, fromCursor, caseFold);
|
||||
},
|
||||
|
||||
undo: function() {this.editor.history.undo();},
|
||||
redo: function() {this.editor.history.redo();},
|
||||
historySize: function() {return this.editor.history.historySize();},
|
||||
clearHistory: function() {this.editor.history.clear();},
|
||||
|
||||
grabKeys: function(callback, filter) {this.editor.grabKeys(callback, filter);},
|
||||
ungrabKeys: function() {this.editor.ungrabKeys();},
|
||||
|
||||
setParser: function(name) {this.editor.setParser(name);},
|
||||
setSpellcheck: function(on) {this.win.document.body.spellcheck = on;},
|
||||
setTextWrapping: function(on) {
|
||||
if (on == this.options.textWrapping) return;
|
||||
this.win.document.body.style.whiteSpace = on ? "" : "nowrap";
|
||||
this.options.textWrapping = on;
|
||||
if (this.lineNumbers) {
|
||||
this.setLineNumbers(false);
|
||||
this.setLineNumbers(true);
|
||||
}
|
||||
},
|
||||
setIndentUnit: function(unit) {this.win.indentUnit = unit;},
|
||||
setUndoDepth: function(depth) {this.editor.history.maxDepth = depth;},
|
||||
setTabMode: function(mode) {this.options.tabMode = mode;},
|
||||
setLineNumbers: function(on) {
|
||||
if (on && !this.lineNumbers) {
|
||||
this.lineNumbers = addLineNumberDiv(this.wrapping);
|
||||
this.activateLineNumbers();
|
||||
}
|
||||
else if (!on && this.lineNumbers) {
|
||||
this.wrapping.removeChild(this.lineNumbers);
|
||||
this.wrapping.style.marginLeft = "";
|
||||
this.lineNumbers = null;
|
||||
}
|
||||
},
|
||||
|
||||
cursorPosition: function(start) {this.focusIfIE(); return this.editor.cursorPosition(start);},
|
||||
firstLine: function() {return this.editor.firstLine();},
|
||||
lastLine: function() {return this.editor.lastLine();},
|
||||
nextLine: function(line) {return this.editor.nextLine(line);},
|
||||
prevLine: function(line) {return this.editor.prevLine(line);},
|
||||
lineContent: function(line) {return this.editor.lineContent(line);},
|
||||
setLineContent: function(line, content) {this.editor.setLineContent(line, content);},
|
||||
removeLine: function(line){this.editor.removeLine(line);},
|
||||
insertIntoLine: function(line, position, content) {this.editor.insertIntoLine(line, position, content);},
|
||||
selectLines: function(startLine, startOffset, endLine, endOffset) {
|
||||
this.win.focus();
|
||||
this.editor.selectLines(startLine, startOffset, endLine, endOffset);
|
||||
},
|
||||
nthLine: function(n) {
|
||||
var line = this.firstLine();
|
||||
for (; n > 1 && line !== false; n--)
|
||||
line = this.nextLine(line);
|
||||
return line;
|
||||
},
|
||||
lineNumber: function(line) {
|
||||
var num = 0;
|
||||
while (line !== false) {
|
||||
num++;
|
||||
line = this.prevLine(line);
|
||||
}
|
||||
return num;
|
||||
},
|
||||
|
||||
// Old number-based line interface
|
||||
jumpToLine: function(n) {
|
||||
this.selectLines(this.nthLine(n), 0);
|
||||
this.win.focus();
|
||||
},
|
||||
currentLine: function() {
|
||||
return this.lineNumber(this.cursorPosition().line);
|
||||
},
|
||||
|
||||
activateLineNumbers: function() {
|
||||
var frame = this.frame, win = frame.contentWindow, doc = win.document, body = doc.body,
|
||||
nums = this.lineNumbers, scroller = nums.firstChild, self = this;
|
||||
var barWidth = null;
|
||||
|
||||
function sizeBar() {
|
||||
if (frame.offsetWidth == 0) return;
|
||||
for (var root = frame; root.parentNode; root = root.parentNode);
|
||||
if (!nums.parentNode || root != document || !win.Editor) {
|
||||
// Clear event handlers (their nodes might already be collected, so try/catch)
|
||||
try{clear();}catch(e){}
|
||||
clearInterval(sizeInterval);
|
||||
return;
|
||||
}
|
||||
|
||||
if (nums.offsetWidth != barWidth) {
|
||||
barWidth = nums.offsetWidth;
|
||||
nums.style.left = "-" + (frame.parentNode.style.marginLeft = barWidth + "px");
|
||||
}
|
||||
}
|
||||
function doScroll() {
|
||||
nums.scrollTop = body.scrollTop || doc.documentElement.scrollTop || 0;
|
||||
}
|
||||
// Cleanup function, registered by nonWrapping and wrapping.
|
||||
var clear = function(){};
|
||||
sizeBar();
|
||||
var sizeInterval = setInterval(sizeBar, 500);
|
||||
|
||||
function nonWrapping() {
|
||||
var nextNum = 1;
|
||||
function update() {
|
||||
var target = 50 + Math.max(body.offsetHeight, frame.offsetHeight);
|
||||
while (scroller.offsetHeight < target) {
|
||||
scroller.appendChild(document.createElement("DIV"));
|
||||
scroller.lastChild.innerHTML = nextNum++;
|
||||
}
|
||||
doScroll();
|
||||
}
|
||||
var onScroll = win.addEventHandler(win, "scroll", update, true),
|
||||
onResize = win.addEventHandler(win, "resize", update, true);
|
||||
clear = function(){onScroll(); onResize();};
|
||||
}
|
||||
function wrapping() {
|
||||
var node, lineNum, next, pos;
|
||||
|
||||
function addNum(n) {
|
||||
if (!lineNum) lineNum = scroller.appendChild(document.createElement("DIV"));
|
||||
lineNum.innerHTML = n;
|
||||
pos = lineNum.offsetHeight + lineNum.offsetTop;
|
||||
lineNum = lineNum.nextSibling;
|
||||
}
|
||||
function work() {
|
||||
if (!scroller.parentNode || scroller.parentNode != self.lineNumbers) return;
|
||||
|
||||
var endTime = new Date().getTime() + self.options.lineNumberTime;
|
||||
while (node) {
|
||||
addNum(next++);
|
||||
for (; node && !win.isBR(node); node = node.nextSibling) {
|
||||
var bott = node.offsetTop + node.offsetHeight;
|
||||
while (bott - 3 > pos) addNum(" ");
|
||||
}
|
||||
if (node) node = node.nextSibling;
|
||||
if (new Date().getTime() > endTime) {
|
||||
pending = setTimeout(work, self.options.lineNumberDelay);
|
||||
return;
|
||||
}
|
||||
}
|
||||
// While there are un-processed number DIVs, or the scroller is smaller than the frame...
|
||||
var target = 50 + Math.max(body.offsetHeight, frame.offsetHeight);
|
||||
while (lineNum || scroller.offsetHeight < target) addNum(next++);
|
||||
doScroll();
|
||||
}
|
||||
function start() {
|
||||
doScroll();
|
||||
node = body.firstChild;
|
||||
lineNum = scroller.firstChild;
|
||||
pos = 0;
|
||||
next = 1;
|
||||
work();
|
||||
}
|
||||
|
||||
start();
|
||||
var pending = null;
|
||||
function update() {
|
||||
if (pending) clearTimeout(pending);
|
||||
if (self.editor.allClean()) start();
|
||||
else pending = setTimeout(update, 200);
|
||||
}
|
||||
self.updateNumbers = update;
|
||||
var onScroll = win.addEventHandler(win, "scroll", doScroll, true),
|
||||
onResize = win.addEventHandler(win, "resize", update, true);
|
||||
clear = function(){
|
||||
if (pending) clearTimeout(pending);
|
||||
if (self.updateNumbers == update) self.updateNumbers = null;
|
||||
onScroll();
|
||||
onResize();
|
||||
};
|
||||
}
|
||||
(this.options.textWrapping ? wrapping : nonWrapping)();
|
||||
}
|
||||
};
|
||||
|
||||
CodeMirror.InvalidLineHandle = {toString: function(){return "CodeMirror.InvalidLineHandle";}};
|
||||
|
||||
CodeMirror.replace = function(element) {
|
||||
if (typeof element == "string")
|
||||
element = document.getElementById(element);
|
||||
return function(newElement) {
|
||||
element.parentNode.replaceChild(newElement, element);
|
||||
};
|
||||
};
|
||||
|
||||
CodeMirror.fromTextArea = function(area, options) {
|
||||
if (typeof area == "string")
|
||||
area = document.getElementById(area);
|
||||
|
||||
options = options || {};
|
||||
if (area.style.width && options.width == null)
|
||||
options.width = area.style.width;
|
||||
if (area.style.height && options.height == null)
|
||||
options.height = area.style.height;
|
||||
if (options.content == null) options.content = area.value;
|
||||
|
||||
if (area.form) {
|
||||
function updateField() {
|
||||
area.value = mirror.getCode();
|
||||
}
|
||||
if (typeof area.form.addEventListener == "function")
|
||||
area.form.addEventListener("submit", updateField, false);
|
||||
else
|
||||
area.form.attachEvent("onsubmit", updateField);
|
||||
}
|
||||
|
||||
function insert(frame) {
|
||||
if (area.nextSibling)
|
||||
area.parentNode.insertBefore(frame, area.nextSibling);
|
||||
else
|
||||
area.parentNode.appendChild(frame);
|
||||
}
|
||||
|
||||
area.style.display = "none";
|
||||
var mirror = new CodeMirror(insert, options);
|
||||
return mirror;
|
||||
};
|
||||
|
||||
CodeMirror.isProbablySupported = function() {
|
||||
// This is rather awful, but can be useful.
|
||||
var match;
|
||||
if (window.opera)
|
||||
return Number(window.opera.version()) >= 9.52;
|
||||
else if (/Apple Computers, Inc/.test(navigator.vendor) && (match = navigator.userAgent.match(/Version\/(\d+(?:\.\d+)?)\./)))
|
||||
return Number(match[1]) >= 3;
|
||||
else if (document.selection && window.ActiveXObject && (match = navigator.userAgent.match(/MSIE (\d+(?:\.\d*)?)\b/)))
|
||||
return Number(match[1]) >= 6;
|
||||
else if (match = navigator.userAgent.match(/gecko\/(\d{8})/i))
|
||||
return Number(match[1]) >= 20050901;
|
||||
else if (match = navigator.userAgent.match(/AppleWebKit\/(\d+)/))
|
||||
return Number(match[1]) >= 525;
|
||||
else
|
||||
return null;
|
||||
};
|
||||
|
||||
return CodeMirror;
|
||||
})();
|
||||
File diff suppressed because it is too large
Load Diff
@ -1,68 +0,0 @@
|
||||
// Minimal framing needed to use CodeMirror-style parsers to highlight
|
||||
// code. Load this along with tokenize.js, stringstream.js, and your
|
||||
// parser. Then call highlightText, passing a string as the first
|
||||
// argument, and as the second argument either a callback function
|
||||
// that will be called with an array of SPAN nodes for every line in
|
||||
// the code, or a DOM node to which to append these spans, and
|
||||
// optionally (not needed if you only loaded one parser) a parser
|
||||
// object.
|
||||
|
||||
// Stuff from util.js that the parsers are using.
|
||||
var StopIteration = {toString: function() {return "StopIteration"}};
|
||||
|
||||
var Editor = {};
|
||||
var indentUnit = 2;
|
||||
|
||||
(function(){
|
||||
function normaliseString(string) {
|
||||
var tab = "";
|
||||
for (var i = 0; i < indentUnit; i++) tab += " ";
|
||||
|
||||
string = string.replace(/\t/g, tab).replace(/\u00a0/g, " ").replace(/\r\n?/g, "\n");
|
||||
var pos = 0, parts = [], lines = string.split("\n");
|
||||
for (var line = 0; line < lines.length; line++) {
|
||||
if (line != 0) parts.push("\n");
|
||||
parts.push(lines[line]);
|
||||
}
|
||||
|
||||
return {
|
||||
next: function() {
|
||||
if (pos < parts.length) return parts[pos++];
|
||||
else throw StopIteration;
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
window.highlightText = function(string, callback, parser) {
|
||||
var parser = (parser || Editor.Parser).make(stringStream(normaliseString(string)));
|
||||
var line = [];
|
||||
if (callback.nodeType == 1) {
|
||||
var node = callback;
|
||||
callback = function(line) {
|
||||
for (var i = 0; i < line.length; i++)
|
||||
node.appendChild(line[i]);
|
||||
node.appendChild(document.createElement("BR"));
|
||||
};
|
||||
}
|
||||
|
||||
try {
|
||||
while (true) {
|
||||
var token = parser.next();
|
||||
if (token.value == "\n") {
|
||||
callback(line);
|
||||
line = [];
|
||||
}
|
||||
else {
|
||||
var span = document.createElement("SPAN");
|
||||
span.className = token.style;
|
||||
span.appendChild(document.createTextNode(token.value));
|
||||
line.push(span);
|
||||
}
|
||||
}
|
||||
}
|
||||
catch (e) {
|
||||
if (e != StopIteration) throw e;
|
||||
}
|
||||
if (line.length) callback(line);
|
||||
}
|
||||
})();
|
||||
@ -1,81 +0,0 @@
|
||||
/* Demonstration of embedding CodeMirror in a bigger application. The
|
||||
* interface defined here is a mess of prompts and confirms, and
|
||||
* should probably not be used in a real project.
|
||||
*/
|
||||
|
||||
function MirrorFrame(place, options) {
|
||||
this.home = document.createElement("DIV");
|
||||
if (place.appendChild)
|
||||
place.appendChild(this.home);
|
||||
else
|
||||
place(this.home);
|
||||
|
||||
var self = this;
|
||||
function makeButton(name, action) {
|
||||
var button = document.createElement("INPUT");
|
||||
button.type = "button";
|
||||
button.value = name;
|
||||
self.home.appendChild(button);
|
||||
button.onclick = function(){self[action].call(self);};
|
||||
}
|
||||
|
||||
makeButton("Search", "search");
|
||||
makeButton("Replace", "replace");
|
||||
makeButton("Current line", "line");
|
||||
makeButton("Jump to line", "jump");
|
||||
makeButton("Insert constructor", "macro");
|
||||
makeButton("Indent all", "reindent");
|
||||
|
||||
this.mirror = new CodeMirror(this.home, options);
|
||||
}
|
||||
|
||||
MirrorFrame.prototype = {
|
||||
search: function() {
|
||||
var text = prompt("Enter search term:", "");
|
||||
if (!text) return;
|
||||
|
||||
var first = true;
|
||||
do {
|
||||
var cursor = this.mirror.getSearchCursor(text, first, true);
|
||||
first = false;
|
||||
while (cursor.findNext()) {
|
||||
cursor.select();
|
||||
if (!confirm("Search again?"))
|
||||
return;
|
||||
}
|
||||
} while (confirm("End of document reached. Start over?"));
|
||||
},
|
||||
|
||||
replace: function() {
|
||||
// This is a replace-all, but it is possible to implement a
|
||||
// prompting replace.
|
||||
var from = prompt("Enter search string:", ""), to;
|
||||
if (from) to = prompt("What should it be replaced with?", "");
|
||||
if (to == null) return;
|
||||
|
||||
var cursor = this.mirror.getSearchCursor(from, false);
|
||||
while (cursor.findNext())
|
||||
cursor.replace(to);
|
||||
},
|
||||
|
||||
jump: function() {
|
||||
var line = prompt("Jump to line:", "");
|
||||
if (line && !isNaN(Number(line)))
|
||||
this.mirror.jumpToLine(Number(line));
|
||||
},
|
||||
|
||||
line: function() {
|
||||
alert("The cursor is currently at line " + this.mirror.currentLine());
|
||||
this.mirror.focus();
|
||||
},
|
||||
|
||||
macro: function() {
|
||||
var name = prompt("Name your constructor:", "");
|
||||
if (name)
|
||||
this.mirror.replaceSelection("function " + name + "() {\n \n}\n\n" + name + ".prototype = {\n \n};\n");
|
||||
},
|
||||
|
||||
reindent: function() {
|
||||
this.mirror.reindent();
|
||||
}
|
||||
};
|
||||
@ -1,155 +0,0 @@
|
||||
/* Simple parser for CSS */
|
||||
|
||||
var CSSParser = Editor.Parser = (function() {
|
||||
var tokenizeCSS = (function() {
|
||||
function normal(source, setState) {
|
||||
var ch = source.next();
|
||||
if (ch == "@") {
|
||||
source.nextWhileMatches(/\w/);
|
||||
return "css-at";
|
||||
}
|
||||
else if (ch == "/" && source.equals("*")) {
|
||||
setState(inCComment);
|
||||
return null;
|
||||
}
|
||||
else if (ch == "<" && source.equals("!")) {
|
||||
setState(inSGMLComment);
|
||||
return null;
|
||||
}
|
||||
else if (ch == "=") {
|
||||
return "css-compare";
|
||||
}
|
||||
else if (source.equals("=") && (ch == "~" || ch == "|")) {
|
||||
source.next();
|
||||
return "css-compare";
|
||||
}
|
||||
else if (ch == "\"" || ch == "'") {
|
||||
setState(inString(ch));
|
||||
return null;
|
||||
}
|
||||
else if (ch == "#") {
|
||||
source.nextWhileMatches(/\w/);
|
||||
return "css-hash";
|
||||
}
|
||||
else if (ch == "!") {
|
||||
source.nextWhileMatches(/[ \t]/);
|
||||
source.nextWhileMatches(/\w/);
|
||||
return "css-important";
|
||||
}
|
||||
else if (/\d/.test(ch)) {
|
||||
source.nextWhileMatches(/[\w.%]/);
|
||||
return "css-unit";
|
||||
}
|
||||
else if (/[,.+>*\/]/.test(ch)) {
|
||||
return "css-select-op";
|
||||
}
|
||||
else if (/[;{}:\[\]]/.test(ch)) {
|
||||
return "css-punctuation";
|
||||
}
|
||||
else {
|
||||
source.nextWhileMatches(/[\w\\\-_]/);
|
||||
return "css-identifier";
|
||||
}
|
||||
}
|
||||
|
||||
function inCComment(source, setState) {
|
||||
var maybeEnd = false;
|
||||
while (!source.endOfLine()) {
|
||||
var ch = source.next();
|
||||
if (maybeEnd && ch == "/") {
|
||||
setState(normal);
|
||||
break;
|
||||
}
|
||||
maybeEnd = (ch == "*");
|
||||
}
|
||||
return "css-comment";
|
||||
}
|
||||
|
||||
function inSGMLComment(source, setState) {
|
||||
var dashes = 0;
|
||||
while (!source.endOfLine()) {
|
||||
var ch = source.next();
|
||||
if (dashes >= 2 && ch == ">") {
|
||||
setState(normal);
|
||||
break;
|
||||
}
|
||||
dashes = (ch == "-") ? dashes + 1 : 0;
|
||||
}
|
||||
return "css-comment";
|
||||
}
|
||||
|
||||
function inString(quote) {
|
||||
return function(source, setState) {
|
||||
var escaped = false;
|
||||
while (!source.endOfLine()) {
|
||||
var ch = source.next();
|
||||
if (ch == quote && !escaped)
|
||||
break;
|
||||
escaped = !escaped && ch == "\\";
|
||||
}
|
||||
if (!escaped)
|
||||
setState(normal);
|
||||
return "css-string";
|
||||
};
|
||||
}
|
||||
|
||||
return function(source, startState) {
|
||||
return tokenizer(source, startState || normal);
|
||||
};
|
||||
})();
|
||||
|
||||
function indentCSS(inBraces, inRule, base) {
|
||||
return function(nextChars) {
|
||||
if (!inBraces || /^\}/.test(nextChars)) return base;
|
||||
else if (inRule) return base + indentUnit * 2;
|
||||
else return base + indentUnit;
|
||||
};
|
||||
}
|
||||
|
||||
// This is a very simplistic parser -- since CSS does not really
|
||||
// nest, it works acceptably well, but some nicer colouroing could
|
||||
// be provided with a more complicated parser.
|
||||
function parseCSS(source, basecolumn) {
|
||||
basecolumn = basecolumn || 0;
|
||||
var tokens = tokenizeCSS(source);
|
||||
var inBraces = false, inRule = false;
|
||||
|
||||
var iter = {
|
||||
next: function() {
|
||||
var token = tokens.next(), style = token.style, content = token.content;
|
||||
|
||||
if (style == "css-identifier" && inRule)
|
||||
token.style = "css-value";
|
||||
if (style == "css-hash")
|
||||
token.style = inRule ? "css-colorcode" : "css-identifier";
|
||||
|
||||
if (content == "\n")
|
||||
token.indentation = indentCSS(inBraces, inRule, basecolumn);
|
||||
|
||||
if (content == "{")
|
||||
inBraces = true;
|
||||
else if (content == "}")
|
||||
inBraces = inRule = false;
|
||||
else if (inBraces && content == ";")
|
||||
inRule = false;
|
||||
else if (inBraces && style != "css-comment" && style != "whitespace")
|
||||
inRule = true;
|
||||
|
||||
return token;
|
||||
},
|
||||
|
||||
copy: function() {
|
||||
var _inBraces = inBraces, _inRule = inRule, _tokenState = tokens.state;
|
||||
return function(source) {
|
||||
tokens = tokenizeCSS(source, _tokenState);
|
||||
inBraces = _inBraces;
|
||||
inRule = _inRule;
|
||||
return iter;
|
||||
};
|
||||
}
|
||||
};
|
||||
return iter;
|
||||
}
|
||||
|
||||
return {make: parseCSS, electricChars: "}"};
|
||||
})();
|
||||
@ -1,32 +0,0 @@
|
||||
var DummyParser = Editor.Parser = (function() {
|
||||
function tokenizeDummy(source) {
|
||||
while (!source.endOfLine()) source.next();
|
||||
return "text";
|
||||
}
|
||||
function parseDummy(source) {
|
||||
function indentTo(n) {return function() {return n;}}
|
||||
source = tokenizer(source, tokenizeDummy);
|
||||
var space = 0;
|
||||
|
||||
var iter = {
|
||||
next: function() {
|
||||
var tok = source.next();
|
||||
if (tok.type == "whitespace") {
|
||||
if (tok.value == "\n") tok.indentation = indentTo(space);
|
||||
else space = tok.value.length;
|
||||
}
|
||||
return tok;
|
||||
},
|
||||
copy: function() {
|
||||
var _space = space;
|
||||
return function(_source) {
|
||||
space = _space;
|
||||
source = tokenizer(_source, tokenizeDummy);
|
||||
return iter;
|
||||
};
|
||||
}
|
||||
};
|
||||
return iter;
|
||||
}
|
||||
return {make: parseDummy};
|
||||
})();
|
||||
@ -1,74 +0,0 @@
|
||||
var HTMLMixedParser = Editor.Parser = (function() {
|
||||
if (!(CSSParser && JSParser && XMLParser))
|
||||
throw new Error("CSS, JS, and XML parsers must be loaded for HTML mixed mode to work.");
|
||||
XMLParser.configure({useHTMLKludges: true});
|
||||
|
||||
function parseMixed(stream) {
|
||||
var htmlParser = XMLParser.make(stream), localParser = null, inTag = false;
|
||||
var iter = {next: top, copy: copy};
|
||||
|
||||
function top() {
|
||||
var token = htmlParser.next();
|
||||
if (token.content == "<")
|
||||
inTag = true;
|
||||
else if (token.style == "xml-tagname" && inTag === true)
|
||||
inTag = token.content.toLowerCase();
|
||||
else if (token.content == ">") {
|
||||
if (inTag == "script")
|
||||
iter.next = local(JSParser, "</script");
|
||||
else if (inTag == "style")
|
||||
iter.next = local(CSSParser, "</style");
|
||||
inTag = false;
|
||||
}
|
||||
return token;
|
||||
}
|
||||
function local(parser, tag) {
|
||||
var baseIndent = htmlParser.indentation();
|
||||
localParser = parser.make(stream, baseIndent + indentUnit);
|
||||
return function() {
|
||||
if (stream.lookAhead(tag, false, false, true)) {
|
||||
localParser = null;
|
||||
iter.next = top;
|
||||
return top();
|
||||
}
|
||||
|
||||
var token = localParser.next();
|
||||
var lt = token.value.lastIndexOf("<"), sz = Math.min(token.value.length - lt, tag.length);
|
||||
if (lt != -1 && token.value.slice(lt, lt + sz).toLowerCase() == tag.slice(0, sz) &&
|
||||
stream.lookAhead(tag.slice(sz), false, false, true)) {
|
||||
stream.push(token.value.slice(lt));
|
||||
token.value = token.value.slice(0, lt);
|
||||
}
|
||||
|
||||
if (token.indentation) {
|
||||
var oldIndent = token.indentation;
|
||||
token.indentation = function(chars) {
|
||||
if (chars == "</")
|
||||
return baseIndent;
|
||||
else
|
||||
return oldIndent(chars);
|
||||
}
|
||||
}
|
||||
|
||||
return token;
|
||||
};
|
||||
}
|
||||
|
||||
function copy() {
|
||||
var _html = htmlParser.copy(), _local = localParser && localParser.copy(),
|
||||
_next = iter.next, _inTag = inTag;
|
||||
return function(_stream) {
|
||||
stream = _stream;
|
||||
htmlParser = _html(_stream);
|
||||
localParser = _local && _local(_stream);
|
||||
iter.next = _next;
|
||||
inTag = _inTag;
|
||||
return iter;
|
||||
};
|
||||
}
|
||||
return iter;
|
||||
}
|
||||
|
||||
return {make: parseMixed, electricChars: "{}/:"};
|
||||
|
||||
})();
|
||||
@ -1,350 +0,0 @@
|
||||
/* Parse function for JavaScript. Makes use of the tokenizer from
|
||||
* tokenizejavascript.js. Note that your parsers do not have to be
|
||||
* this complicated -- if you don't want to recognize local variables,
|
||||
* in many languages it is enough to just look for braces, semicolons,
|
||||
* parentheses, etc, and know when you are inside a string or comment.
|
||||
*
|
||||
* See manual.html for more info about the parser interface.
|
||||
*/
|
||||
|
||||
var JSParser = Editor.Parser = (function() {
|
||||
// Token types that can be considered to be atoms.
|
||||
var atomicTypes = {"atom": true, "number": true, "variable": true, "string": true, "regexp": true};
|
||||
// Setting that can be used to have JSON data indent properly.
|
||||
var json = false;
|
||||
// Constructor for the lexical context objects.
|
||||
function JSLexical(indented, column, type, align, prev, info) {
|
||||
// indentation at start of this line
|
||||
this.indented = indented;
|
||||
// column at which this scope was opened
|
||||
this.column = column;
|
||||
// type of scope ('vardef', 'stat' (statement), 'form' (special form), '[', '{', or '(')
|
||||
this.type = type;
|
||||
// '[', '{', or '(' blocks that have any text after their opening
|
||||
// character are said to be 'aligned' -- any lines below are
|
||||
// indented all the way to the opening character.
|
||||
if (align != null)
|
||||
this.align = align;
|
||||
// Parent scope, if any.
|
||||
this.prev = prev;
|
||||
this.info = info;
|
||||
}
|
||||
|
||||
// My favourite JavaScript indentation rules.
|
||||
function indentJS(lexical) {
|
||||
return function(firstChars) {
|
||||
var firstChar = firstChars && firstChars.charAt(0), type = lexical.type;
|
||||
var closing = firstChar == type;
|
||||
if (type == "vardef")
|
||||
return lexical.indented + 4;
|
||||
else if (type == "form" && firstChar == "{")
|
||||
return lexical.indented;
|
||||
else if (type == "stat" || type == "form")
|
||||
return lexical.indented + indentUnit;
|
||||
else if (lexical.info == "switch" && !closing)
|
||||
return lexical.indented + (/^(?:case|default)\b/.test(firstChars) ? indentUnit : 2 * indentUnit);
|
||||
else if (lexical.align)
|
||||
return lexical.column - (closing ? 1 : 0);
|
||||
else
|
||||
return lexical.indented + (closing ? 0 : indentUnit);
|
||||
};
|
||||
}
|
||||
|
||||
// The parser-iterator-producing function itself.
|
||||
function parseJS(input, basecolumn) {
|
||||
// Wrap the input in a token stream
|
||||
var tokens = tokenizeJavaScript(input);
|
||||
// The parser state. cc is a stack of actions that have to be
|
||||
// performed to finish the current statement. For example we might
|
||||
// know that we still need to find a closing parenthesis and a
|
||||
// semicolon. Actions at the end of the stack go first. It is
|
||||
// initialized with an infinitely looping action that consumes
|
||||
// whole statements.
|
||||
var cc = [statements];
|
||||
// Context contains information about the current local scope, the
|
||||
// variables defined in that, and the scopes above it.
|
||||
var context = null;
|
||||
// The lexical scope, used mostly for indentation.
|
||||
var lexical = new JSLexical((basecolumn || 0) - indentUnit, 0, "block", false);
|
||||
// Current column, and the indentation at the start of the current
|
||||
// line. Used to create lexical scope objects.
|
||||
var column = 0;
|
||||
var indented = 0;
|
||||
// Variables which are used by the mark, cont, and pass functions
|
||||
// below to communicate with the driver loop in the 'next'
|
||||
// function.
|
||||
var consume, marked;
|
||||
|
||||
// The iterator object.
|
||||
var parser = {next: next, copy: copy};
|
||||
|
||||
function next(){
|
||||
// Start by performing any 'lexical' actions (adjusting the
|
||||
// lexical variable), or the operations below will be working
|
||||
// with the wrong lexical state.
|
||||
while(cc[cc.length - 1].lex)
|
||||
cc.pop()();
|
||||
|
||||
// Fetch a token.
|
||||
var token = tokens.next();
|
||||
|
||||
// Adjust column and indented.
|
||||
if (token.type == "whitespace" && column == 0)
|
||||
indented = token.value.length;
|
||||
column += token.value.length;
|
||||
if (token.content == "\n"){
|
||||
indented = column = 0;
|
||||
// If the lexical scope's align property is still undefined at
|
||||
// the end of the line, it is an un-aligned scope.
|
||||
if (!("align" in lexical))
|
||||
lexical.align = false;
|
||||
// Newline tokens get an indentation function associated with
|
||||
// them.
|
||||
token.indentation = indentJS(lexical);
|
||||
}
|
||||
// No more processing for meaningless tokens.
|
||||
if (token.type == "whitespace" || token.type == "comment")
|
||||
return token;
|
||||
// When a meaningful token is found and the lexical scope's
|
||||
// align is undefined, it is an aligned scope.
|
||||
if (!("align" in lexical))
|
||||
lexical.align = true;
|
||||
|
||||
// Execute actions until one 'consumes' the token and we can
|
||||
// return it.
|
||||
while(true) {
|
||||
consume = marked = false;
|
||||
// Take and execute the topmost action.
|
||||
cc.pop()(token.type, token.content);
|
||||
if (consume){
|
||||
// Marked is used to change the style of the current token.
|
||||
if (marked)
|
||||
token.style = marked;
|
||||
// Here we differentiate between local and global variables.
|
||||
else if (token.type == "variable" && inScope(token.content))
|
||||
token.style = "js-localvariable";
|
||||
return token;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// This makes a copy of the parser state. It stores all the
|
||||
// stateful variables in a closure, and returns a function that
|
||||
// will restore them when called with a new input stream. Note
|
||||
// that the cc array has to be copied, because it is contantly
|
||||
// being modified. Lexical objects are not mutated, and context
|
||||
// objects are not mutated in a harmful way, so they can be shared
|
||||
// between runs of the parser.
|
||||
function copy(){
|
||||
var _context = context, _lexical = lexical, _cc = cc.concat([]), _tokenState = tokens.state;
|
||||
|
||||
return function copyParser(input){
|
||||
context = _context;
|
||||
lexical = _lexical;
|
||||
cc = _cc.concat([]); // copies the array
|
||||
column = indented = 0;
|
||||
tokens = tokenizeJavaScript(input, _tokenState);
|
||||
return parser;
|
||||
};
|
||||
}
|
||||
|
||||
// Helper function for pushing a number of actions onto the cc
|
||||
// stack in reverse order.
|
||||
function push(fs){
|
||||
for (var i = fs.length - 1; i >= 0; i--)
|
||||
cc.push(fs[i]);
|
||||
}
|
||||
// cont and pass are used by the action functions to add other
|
||||
// actions to the stack. cont will cause the current token to be
|
||||
// consumed, pass will leave it for the next action.
|
||||
function cont(){
|
||||
push(arguments);
|
||||
consume = true;
|
||||
}
|
||||
function pass(){
|
||||
push(arguments);
|
||||
consume = false;
|
||||
}
|
||||
// Used to change the style of the current token.
|
||||
function mark(style){
|
||||
marked = style;
|
||||
}
|
||||
|
||||
// Push a new scope. Will automatically link the current scope.
|
||||
function pushcontext(){
|
||||
context = {prev: context, vars: {"this": true, "arguments": true}};
|
||||
}
|
||||
// Pop off the current scope.
|
||||
function popcontext(){
|
||||
context = context.prev;
|
||||
}
|
||||
// Register a variable in the current scope.
|
||||
function register(varname){
|
||||
if (context){
|
||||
mark("js-variabledef");
|
||||
context.vars[varname] = true;
|
||||
}
|
||||
}
|
||||
// Check whether a variable is defined in the current scope.
|
||||
function inScope(varname){
|
||||
var cursor = context;
|
||||
while (cursor) {
|
||||
if (cursor.vars[varname])
|
||||
return true;
|
||||
cursor = cursor.prev;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
// Push a new lexical context of the given type.
|
||||
function pushlex(type, info) {
|
||||
var result = function(){
|
||||
lexical = new JSLexical(indented, column, type, null, lexical, info)
|
||||
};
|
||||
result.lex = true;
|
||||
return result;
|
||||
}
|
||||
// Pop off the current lexical context.
|
||||
function poplex(){
|
||||
lexical = lexical.prev;
|
||||
}
|
||||
poplex.lex = true;
|
||||
// The 'lex' flag on these actions is used by the 'next' function
|
||||
// to know they can (and have to) be ran before moving on to the
|
||||
// next token.
|
||||
|
||||
// Creates an action that discards tokens until it finds one of
|
||||
// the given type.
|
||||
function expect(wanted){
|
||||
return function expecting(type){
|
||||
if (type == wanted) cont();
|
||||
else cont(arguments.callee);
|
||||
};
|
||||
}
|
||||
|
||||
// Looks for a statement, and then calls itself.
|
||||
function statements(type){
|
||||
return pass(statement, statements);
|
||||
}
|
||||
// Dispatches various types of statements based on the type of the
|
||||
// current token.
|
||||
function statement(type){
|
||||
if (type == "var") cont(pushlex("vardef"), vardef1, expect(";"), poplex);
|
||||
else if (type == "keyword a") cont(pushlex("form"), expression, statement, poplex);
|
||||
else if (type == "keyword b") cont(pushlex("form"), statement, poplex);
|
||||
else if (type == "{" && json) cont(pushlex("}"), commasep(objprop, "}"), poplex);
|
||||
else if (type == "{") cont(pushlex("}"), block, poplex);
|
||||
else if (type == "function") cont(functiondef);
|
||||
else if (type == "for") cont(pushlex("form"), expect("("), pushlex(")"), forspec1, expect(")"), poplex, statement, poplex);
|
||||
else if (type == "variable") cont(pushlex("stat"), maybelabel);
|
||||
else if (type == "switch") cont(pushlex("form"), expression, pushlex("}", "switch"), expect("{"), block, poplex, poplex);
|
||||
else if (type == "case") cont(expression, expect(":"));
|
||||
else if (type == "default") cont(expect(":"));
|
||||
else if (type == "catch") cont(pushlex("form"), pushcontext, expect("("), funarg, expect(")"), statement, poplex, popcontext);
|
||||
else pass(pushlex("stat"), expression, expect(";"), poplex);
|
||||
}
|
||||
// Dispatch expression types.
|
||||
function expression(type){
|
||||
if (atomicTypes.hasOwnProperty(type)) cont(maybeoperator);
|
||||
else if (type == "function") cont(functiondef);
|
||||
else if (type == "keyword c") cont(expression);
|
||||
else if (type == "(") cont(pushlex(")"), expression, expect(")"), poplex, maybeoperator);
|
||||
else if (type == "operator") cont(expression);
|
||||
else if (type == "[") cont(pushlex("]"), commasep(expression, "]"), poplex, maybeoperator);
|
||||
else if (type == "{") cont(pushlex("}"), commasep(objprop, "}"), poplex, maybeoperator);
|
||||
}
|
||||
// Called for places where operators, function calls, or
|
||||
// subscripts are valid. Will skip on to the next action if none
|
||||
// is found.
|
||||
function maybeoperator(type){
|
||||
if (type == "operator") cont(expression);
|
||||
else if (type == "(") cont(pushlex(")"), expression, commasep(expression, ")"), poplex, maybeoperator);
|
||||
else if (type == ".") cont(property, maybeoperator);
|
||||
else if (type == "[") cont(pushlex("]"), expression, expect("]"), poplex, maybeoperator);
|
||||
}
|
||||
// When a statement starts with a variable name, it might be a
|
||||
// label. If no colon follows, it's a regular statement.
|
||||
function maybelabel(type){
|
||||
if (type == ":") cont(poplex, statement);
|
||||
else pass(maybeoperator, expect(";"), poplex);
|
||||
}
|
||||
// Property names need to have their style adjusted -- the
|
||||
// tokenizer thinks they are variables.
|
||||
function property(type){
|
||||
if (type == "variable") {mark("js-property"); cont();}
|
||||
}
|
||||
// This parses a property and its value in an object literal.
|
||||
function objprop(type){
|
||||
if (type == "variable") mark("js-property");
|
||||
if (atomicTypes.hasOwnProperty(type)) cont(expect(":"), expression);
|
||||
}
|
||||
// Parses a comma-separated list of the things that are recognized
|
||||
// by the 'what' argument.
|
||||
function commasep(what, end){
|
||||
function proceed(type) {
|
||||
if (type == ",") cont(what, proceed);
|
||||
else if (type == end) cont();
|
||||
else cont(expect(end));
|
||||
};
|
||||
return function commaSeparated(type) {
|
||||
if (type == end) cont();
|
||||
else pass(what, proceed);
|
||||
};
|
||||
}
|
||||
// Look for statements until a closing brace is found.
|
||||
function block(type){
|
||||
if (type == "}") cont();
|
||||
else pass(statement, block);
|
||||
}
|
||||
// Variable definitions are split into two actions -- 1 looks for
|
||||
// a name or the end of the definition, 2 looks for an '=' sign or
|
||||
// a comma.
|
||||
function vardef1(type, value){
|
||||
if (type == "variable"){register(value); cont(vardef2);}
|
||||
else cont();
|
||||
}
|
||||
function vardef2(type, value){
|
||||
if (value == "=") cont(expression, vardef2);
|
||||
else if (type == ",") cont(vardef1);
|
||||
}
|
||||
// For loops.
|
||||
function forspec1(type){
|
||||
if (type == "var") cont(vardef1, forspec2);
|
||||
else if (type == ";") pass(forspec2);
|
||||
else if (type == "variable") cont(formaybein);
|
||||
else pass(forspec2);
|
||||
}
|
||||
function formaybein(type, value){
|
||||
if (value == "in") cont(expression);
|
||||
else cont(maybeoperator, forspec2);
|
||||
}
|
||||
function forspec2(type, value){
|
||||
if (type == ";") cont(forspec3);
|
||||
else if (value == "in") cont(expression);
|
||||
else cont(expression, expect(";"), forspec3);
|
||||
}
|
||||
function forspec3(type) {
|
||||
if (type == ")") pass();
|
||||
else cont(expression);
|
||||
}
|
||||
// A function definition creates a new context, and the variables
|
||||
// in its argument list have to be added to this context.
|
||||
function functiondef(type, value){
|
||||
if (type == "variable"){register(value); cont(functiondef);}
|
||||
else if (type == "(") cont(pushcontext, commasep(funarg, ")"), statement, popcontext);
|
||||
}
|
||||
function funarg(type, value){
|
||||
if (type == "variable"){register(value); cont();}
|
||||
}
|
||||
|
||||
return parser;
|
||||
}
|
||||
|
||||
return {
|
||||
make: parseJS,
|
||||
electricChars: "{}:",
|
||||
configure: function(obj) {
|
||||
if (obj.json != null) json = obj.json;
|
||||
}
|
||||
};
|
||||
})();
|
||||
@ -1,162 +0,0 @@
|
||||
var SparqlParser = Editor.Parser = (function() {
|
||||
function wordRegexp(words) {
|
||||
return new RegExp("^(?:" + words.join("|") + ")$", "i");
|
||||
}
|
||||
var ops = wordRegexp(["str", "lang", "langmatches", "datatype", "bound", "sameterm", "isiri", "isuri",
|
||||
"isblank", "isliteral", "union", "a"]);
|
||||
var keywords = wordRegexp(["base", "prefix", "select", "distinct", "reduced", "construct", "describe",
|
||||
"ask", "from", "named", "where", "order", "limit", "offset", "filter", "optional",
|
||||
"graph", "by", "asc", "desc", ]);
|
||||
var operatorChars = /[*+\-<>=&|]/;
|
||||
|
||||
var tokenizeSparql = (function() {
|
||||
function normal(source, setState) {
|
||||
var ch = source.next();
|
||||
if (ch == "$" || ch == "?") {
|
||||
source.nextWhileMatches(/[\w\d]/);
|
||||
return "sp-var";
|
||||
}
|
||||
else if (ch == "<" && !source.matches(/[\s\u00a0=]/)) {
|
||||
source.nextWhileMatches(/[^\s\u00a0>]/);
|
||||
if (source.equals(">")) source.next();
|
||||
return "sp-uri";
|
||||
}
|
||||
else if (ch == "\"" || ch == "'") {
|
||||
setState(inLiteral(ch));
|
||||
return null;
|
||||
}
|
||||
else if (/[{}\(\),\.;\[\]]/.test(ch)) {
|
||||
return "sp-punc";
|
||||
}
|
||||
else if (ch == "#") {
|
||||
while (!source.endOfLine()) source.next();
|
||||
return "sp-comment";
|
||||
}
|
||||
else if (operatorChars.test(ch)) {
|
||||
source.nextWhileMatches(operatorChars);
|
||||
return "sp-operator";
|
||||
}
|
||||
else if (ch == ":") {
|
||||
source.nextWhileMatches(/[\w\d\._\-]/);
|
||||
return "sp-prefixed";
|
||||
}
|
||||
else {
|
||||
source.nextWhileMatches(/[_\w\d]/);
|
||||
if (source.equals(":")) {
|
||||
source.next();
|
||||
source.nextWhileMatches(/[\w\d_\-]/);
|
||||
return "sp-prefixed";
|
||||
}
|
||||
var word = source.get(), type;
|
||||
if (ops.test(word))
|
||||
type = "sp-operator";
|
||||
else if (keywords.test(word))
|
||||
type = "sp-keyword";
|
||||
else
|
||||
type = "sp-word";
|
||||
return {style: type, content: word};
|
||||
}
|
||||
}
|
||||
|
||||
function inLiteral(quote) {
|
||||
return function(source, setState) {
|
||||
var escaped = false;
|
||||
while (!source.endOfLine()) {
|
||||
var ch = source.next();
|
||||
if (ch == quote && !escaped) {
|
||||
setState(normal);
|
||||
break;
|
||||
}
|
||||
escaped = !escaped && ch == "\\";
|
||||
}
|
||||
return "sp-literal";
|
||||
};
|
||||
}
|
||||
|
||||
return function(source, startState) {
|
||||
return tokenizer(source, startState || normal);
|
||||
};
|
||||
})();
|
||||
|
||||
function indentSparql(context) {
|
||||
return function(nextChars) {
|
||||
var firstChar = nextChars && nextChars.charAt(0);
|
||||
if (/[\]\}]/.test(firstChar))
|
||||
while (context && context.type == "pattern") context = context.prev;
|
||||
|
||||
var closing = context && firstChar == matching[context.type];
|
||||
if (!context)
|
||||
return 0;
|
||||
else if (context.type == "pattern")
|
||||
return context.col;
|
||||
else if (context.align)
|
||||
return context.col - (closing ? context.width : 0);
|
||||
else
|
||||
return context.indent + (closing ? 0 : indentUnit);
|
||||
}
|
||||
}
|
||||
|
||||
function parseSparql(source) {
|
||||
var tokens = tokenizeSparql(source);
|
||||
var context = null, indent = 0, col = 0;
|
||||
function pushContext(type, width) {
|
||||
context = {prev: context, indent: indent, col: col, type: type, width: width};
|
||||
}
|
||||
function popContext() {
|
||||
context = context.prev;
|
||||
}
|
||||
|
||||
var iter = {
|
||||
next: function() {
|
||||
var token = tokens.next(), type = token.style, content = token.content, width = token.value.length;
|
||||
|
||||
if (content == "\n") {
|
||||
token.indentation = indentSparql(context);
|
||||
indent = col = 0;
|
||||
if (context && context.align == null) context.align = false;
|
||||
}
|
||||
else if (type == "whitespace" && col == 0) {
|
||||
indent = width;
|
||||
}
|
||||
else if (type != "sp-comment" && context && context.align == null) {
|
||||
context.align = true;
|
||||
}
|
||||
|
||||
if (content != "\n") col += width;
|
||||
|
||||
if (/[\[\{\(]/.test(content)) {
|
||||
pushContext(content, width);
|
||||
}
|
||||
else if (/[\]\}\)]/.test(content)) {
|
||||
while (context && context.type == "pattern")
|
||||
popContext();
|
||||
if (context && content == matching[context.type])
|
||||
popContext();
|
||||
}
|
||||
else if (content == "." && context && context.type == "pattern") {
|
||||
popContext();
|
||||
}
|
||||
else if ((type == "sp-word" || type == "sp-prefixed" || type == "sp-uri" || type == "sp-var" || type == "sp-literal") &&
|
||||
context && /[\{\[]/.test(context.type)) {
|
||||
pushContext("pattern", width);
|
||||
}
|
||||
|
||||
return token;
|
||||
},
|
||||
|
||||
copy: function() {
|
||||
var _context = context, _indent = indent, _col = col, _tokenState = tokens.state;
|
||||
return function(source) {
|
||||
tokens = tokenizeSparql(source, _tokenState);
|
||||
context = _context;
|
||||
indent = _indent;
|
||||
col = _col;
|
||||
return iter;
|
||||
};
|
||||
}
|
||||
};
|
||||
return iter;
|
||||
}
|
||||
|
||||
return {make: parseSparql, electricChars: "}]"};
|
||||
})();
|
||||
@ -1,286 +0,0 @@
|
||||
/* This file defines an XML parser, with a few kludges to make it
|
||||
* useable for HTML. autoSelfClosers defines a set of tag names that
|
||||
* are expected to not have a closing tag, and doNotIndent specifies
|
||||
* the tags inside of which no indentation should happen (see Config
|
||||
* object). These can be disabled by passing the editor an object like
|
||||
* {useHTMLKludges: false} as parserConfig option.
|
||||
*/
|
||||
|
||||
var XMLParser = Editor.Parser = (function() {
|
||||
var Kludges = {
|
||||
autoSelfClosers: {"br": true, "img": true, "hr": true, "link": true, "input": true,
|
||||
"meta": true, "col": true, "frame": true, "base": true, "area": true},
|
||||
doNotIndent: {"pre": true, "!cdata": true}
|
||||
};
|
||||
var NoKludges = {autoSelfClosers: {}, doNotIndent: {"!cdata": true}};
|
||||
var UseKludges = Kludges;
|
||||
var alignCDATA = false;
|
||||
|
||||
// Simple stateful tokenizer for XML documents. Returns a
|
||||
// MochiKit-style iterator, with a state property that contains a
|
||||
// function encapsulating the current state. See tokenize.js.
|
||||
var tokenizeXML = (function() {
|
||||
function inText(source, setState) {
|
||||
var ch = source.next();
|
||||
if (ch == "<") {
|
||||
if (source.equals("!")) {
|
||||
source.next();
|
||||
if (source.equals("[")) {
|
||||
if (source.lookAhead("[CDATA[", true)) {
|
||||
setState(inBlock("xml-cdata", "]]>"));
|
||||
return null;
|
||||
}
|
||||
else {
|
||||
return "xml-text";
|
||||
}
|
||||
}
|
||||
else if (source.lookAhead("--", true)) {
|
||||
setState(inBlock("xml-comment", "-->"));
|
||||
return null;
|
||||
}
|
||||
else {
|
||||
return "xml-text";
|
||||
}
|
||||
}
|
||||
else if (source.equals("?")) {
|
||||
source.next();
|
||||
source.nextWhileMatches(/[\w\._\-]/);
|
||||
setState(inBlock("xml-processing", "?>"));
|
||||
return "xml-processing";
|
||||
}
|
||||
else {
|
||||
if (source.equals("/")) source.next();
|
||||
setState(inTag);
|
||||
return "xml-punctuation";
|
||||
}
|
||||
}
|
||||
else if (ch == "&") {
|
||||
while (!source.endOfLine()) {
|
||||
if (source.next() == ";")
|
||||
break;
|
||||
}
|
||||
return "xml-entity";
|
||||
}
|
||||
else {
|
||||
source.nextWhileMatches(/[^&<\n]/);
|
||||
return "xml-text";
|
||||
}
|
||||
}
|
||||
|
||||
function inTag(source, setState) {
|
||||
var ch = source.next();
|
||||
if (ch == ">") {
|
||||
setState(inText);
|
||||
return "xml-punctuation";
|
||||
}
|
||||
else if (/[?\/]/.test(ch) && source.equals(">")) {
|
||||
source.next();
|
||||
setState(inText);
|
||||
return "xml-punctuation";
|
||||
}
|
||||
else if (ch == "=") {
|
||||
return "xml-punctuation";
|
||||
}
|
||||
else if (/[\'\"]/.test(ch)) {
|
||||
setState(inAttribute(ch));
|
||||
return null;
|
||||
}
|
||||
else {
|
||||
source.nextWhileMatches(/[^\s\u00a0=<>\"\'\/?]/);
|
||||
return "xml-name";
|
||||
}
|
||||
}
|
||||
|
||||
function inAttribute(quote) {
|
||||
return function(source, setState) {
|
||||
while (!source.endOfLine()) {
|
||||
if (source.next() == quote) {
|
||||
setState(inTag);
|
||||
break;
|
||||
}
|
||||
}
|
||||
return "xml-attribute";
|
||||
};
|
||||
}
|
||||
|
||||
function inBlock(style, terminator) {
|
||||
return function(source, setState) {
|
||||
while (!source.endOfLine()) {
|
||||
if (source.lookAhead(terminator, true)) {
|
||||
setState(inText);
|
||||
break;
|
||||
}
|
||||
source.next();
|
||||
}
|
||||
return style;
|
||||
};
|
||||
}
|
||||
|
||||
return function(source, startState) {
|
||||
return tokenizer(source, startState || inText);
|
||||
};
|
||||
})();
|
||||
|
||||
// The parser. The structure of this function largely follows that of
|
||||
// parseJavaScript in parsejavascript.js (there is actually a bit more
|
||||
// shared code than I'd like), but it is quite a bit simpler.
|
||||
function parseXML(source) {
|
||||
var tokens = tokenizeXML(source), token;
|
||||
var cc = [base];
|
||||
var tokenNr = 0, indented = 0;
|
||||
var currentTag = null, context = null;
|
||||
var consume;
|
||||
|
||||
function push(fs) {
|
||||
for (var i = fs.length - 1; i >= 0; i--)
|
||||
cc.push(fs[i]);
|
||||
}
|
||||
function cont() {
|
||||
push(arguments);
|
||||
consume = true;
|
||||
}
|
||||
function pass() {
|
||||
push(arguments);
|
||||
consume = false;
|
||||
}
|
||||
|
||||
function markErr() {
|
||||
token.style += " xml-error";
|
||||
}
|
||||
function expect(text) {
|
||||
return function(style, content) {
|
||||
if (content == text) cont();
|
||||
else {markErr(); cont(arguments.callee);}
|
||||
};
|
||||
}
|
||||
|
||||
function pushContext(tagname, startOfLine) {
|
||||
var noIndent = UseKludges.doNotIndent.hasOwnProperty(tagname) || (context && context.noIndent);
|
||||
context = {prev: context, name: tagname, indent: indented, startOfLine: startOfLine, noIndent: noIndent};
|
||||
}
|
||||
function popContext() {
|
||||
context = context.prev;
|
||||
}
|
||||
function computeIndentation(baseContext) {
|
||||
return function(nextChars, current) {
|
||||
var context = baseContext;
|
||||
if (context && context.noIndent)
|
||||
return current;
|
||||
if (alignCDATA && /<!\[CDATA\[/.test(nextChars))
|
||||
return 0;
|
||||
if (context && /^<\//.test(nextChars))
|
||||
context = context.prev;
|
||||
while (context && !context.startOfLine)
|
||||
context = context.prev;
|
||||
if (context)
|
||||
return context.indent + indentUnit;
|
||||
else
|
||||
return 0;
|
||||
};
|
||||
}
|
||||
|
||||
function base() {
|
||||
return pass(element, base);
|
||||
}
|
||||
var harmlessTokens = {"xml-text": true, "xml-entity": true, "xml-comment": true, "xml-processing": true};
|
||||
function element(style, content) {
|
||||
if (content == "<") cont(tagname, attributes, endtag(tokenNr == 1));
|
||||
else if (content == "</") cont(closetagname, expect(">"));
|
||||
else if (style == "xml-cdata") {
|
||||
if (!context || context.name != "!cdata") pushContext("!cdata");
|
||||
if (/\]\]>$/.test(content)) popContext();
|
||||
cont();
|
||||
}
|
||||
else if (harmlessTokens.hasOwnProperty(style)) cont();
|
||||
else {markErr(); cont();}
|
||||
}
|
||||
function tagname(style, content) {
|
||||
if (style == "xml-name") {
|
||||
currentTag = content.toLowerCase();
|
||||
token.style = "xml-tagname";
|
||||
cont();
|
||||
}
|
||||
else {
|
||||
currentTag = null;
|
||||
pass();
|
||||
}
|
||||
}
|
||||
function closetagname(style, content) {
|
||||
if (style == "xml-name") {
|
||||
token.style = "xml-tagname";
|
||||
if (context && content.toLowerCase() == context.name) popContext();
|
||||
else markErr();
|
||||
}
|
||||
cont();
|
||||
}
|
||||
function endtag(startOfLine) {
|
||||
return function(style, content) {
|
||||
if (content == "/>" || (content == ">" && UseKludges.autoSelfClosers.hasOwnProperty(currentTag))) cont();
|
||||
else if (content == ">") {pushContext(currentTag, startOfLine); cont();}
|
||||
else {markErr(); cont(arguments.callee);}
|
||||
};
|
||||
}
|
||||
function attributes(style) {
|
||||
if (style == "xml-name") {token.style = "xml-attname"; cont(attribute, attributes);}
|
||||
else pass();
|
||||
}
|
||||
function attribute(style, content) {
|
||||
if (content == "=") cont(value);
|
||||
else if (content == ">" || content == "/>") pass(endtag);
|
||||
else pass();
|
||||
}
|
||||
function value(style) {
|
||||
if (style == "xml-attribute") cont(value);
|
||||
else pass();
|
||||
}
|
||||
|
||||
return {
|
||||
indentation: function() {return indented;},
|
||||
|
||||
next: function(){
|
||||
token = tokens.next();
|
||||
if (token.style == "whitespace" && tokenNr == 0)
|
||||
indented = token.value.length;
|
||||
else
|
||||
tokenNr++;
|
||||
if (token.content == "\n") {
|
||||
indented = tokenNr = 0;
|
||||
token.indentation = computeIndentation(context);
|
||||
}
|
||||
|
||||
if (token.style == "whitespace" || token.type == "xml-comment")
|
||||
return token;
|
||||
|
||||
while(true){
|
||||
consume = false;
|
||||
cc.pop()(token.style, token.content);
|
||||
if (consume) return token;
|
||||
}
|
||||
},
|
||||
|
||||
copy: function(){
|
||||
var _cc = cc.concat([]), _tokenState = tokens.state, _context = context;
|
||||
var parser = this;
|
||||
|
||||
return function(input){
|
||||
cc = _cc.concat([]);
|
||||
tokenNr = indented = 0;
|
||||
context = _context;
|
||||
tokens = tokenizeXML(input, _tokenState);
|
||||
return parser;
|
||||
};
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
return {
|
||||
make: parseXML,
|
||||
electricChars: "/",
|
||||
configure: function(config) {
|
||||
if (config.useHTMLKludges != null)
|
||||
UseKludges = config.useHTMLKludges ? Kludges : NoKludges;
|
||||
if (config.alignCDATA)
|
||||
alignCDATA = config.alignCDATA;
|
||||
}
|
||||
};
|
||||
})();
|
||||
@ -1,619 +0,0 @@
|
||||
/* Functionality for finding, storing, and restoring selections
|
||||
*
|
||||
* This does not provide a generic API, just the minimal functionality
|
||||
* required by the CodeMirror system.
|
||||
*/
|
||||
|
||||
// Namespace object.
|
||||
var select = {};
|
||||
|
||||
(function() {
|
||||
select.ie_selection = document.selection && document.selection.createRangeCollection;
|
||||
|
||||
// Find the 'top-level' (defined as 'a direct child of the node
|
||||
// passed as the top argument') node that the given node is
|
||||
// contained in. Return null if the given node is not inside the top
|
||||
// node.
|
||||
function topLevelNodeAt(node, top) {
|
||||
while (node && node.parentNode != top)
|
||||
node = node.parentNode;
|
||||
return node;
|
||||
}
|
||||
|
||||
// Find the top-level node that contains the node before this one.
|
||||
function topLevelNodeBefore(node, top) {
|
||||
while (!node.previousSibling && node.parentNode != top)
|
||||
node = node.parentNode;
|
||||
return topLevelNodeAt(node.previousSibling, top);
|
||||
}
|
||||
|
||||
var fourSpaces = "\u00a0\u00a0\u00a0\u00a0";
|
||||
|
||||
select.scrollToNode = function(element) {
|
||||
if (!element) return;
|
||||
var doc = element.ownerDocument, body = doc.body,
|
||||
win = (doc.defaultView || doc.parentWindow),
|
||||
html = doc.documentElement,
|
||||
atEnd = !element.nextSibling || !element.nextSibling.nextSibling
|
||||
|| !element.nextSibling.nextSibling.nextSibling;
|
||||
// In Opera (and recent Webkit versions), BR elements *always*
|
||||
// have a offsetTop property of zero.
|
||||
var compensateHack = 0;
|
||||
while (element && !element.offsetTop) {
|
||||
compensateHack++;
|
||||
element = element.previousSibling;
|
||||
}
|
||||
// atEnd is another kludge for these browsers -- if the cursor is
|
||||
// at the end of the document, and the node doesn't have an
|
||||
// offset, just scroll to the end.
|
||||
if (compensateHack == 0) atEnd = false;
|
||||
|
||||
var y = compensateHack * (element ? element.offsetHeight : 0), x = 0, pos = element;
|
||||
while (pos && pos.offsetParent) {
|
||||
y += pos.offsetTop;
|
||||
// Don't count X offset for <br> nodes
|
||||
if (!isBR(pos))
|
||||
x += pos.offsetLeft;
|
||||
pos = pos.offsetParent;
|
||||
}
|
||||
|
||||
var scroll_x = body.scrollLeft || html.scrollLeft || 0,
|
||||
scroll_y = body.scrollTop || html.scrollTop || 0,
|
||||
screen_x = x - scroll_x, screen_y = y - scroll_y, scroll = false;
|
||||
|
||||
if (screen_x < 0 || screen_x > (win.innerWidth || html.clientWidth || 0)) {
|
||||
scroll_x = x;
|
||||
scroll = true;
|
||||
}
|
||||
if (screen_y < 0 || atEnd || screen_y > (win.innerHeight || html.clientHeight || 0) - 50) {
|
||||
scroll_y = atEnd ? 1e6 : y;
|
||||
scroll = true;
|
||||
}
|
||||
if (scroll) win.scrollTo(scroll_x, scroll_y);
|
||||
};
|
||||
|
||||
select.scrollToCursor = function(container) {
|
||||
select.scrollToNode(select.selectionTopNode(container, true) || container.firstChild);
|
||||
};
|
||||
|
||||
// Used to prevent restoring a selection when we do not need to.
|
||||
var currentSelection = null;
|
||||
|
||||
select.snapshotChanged = function() {
|
||||
if (currentSelection) currentSelection.changed = true;
|
||||
};
|
||||
|
||||
// This is called by the code in editor.js whenever it is replacing
|
||||
// a text node. The function sees whether the given oldNode is part
|
||||
// of the current selection, and updates this selection if it is.
|
||||
// Because nodes are often only partially replaced, the length of
|
||||
// the part that gets replaced has to be taken into account -- the
|
||||
// selection might stay in the oldNode if the newNode is smaller
|
||||
// than the selection's offset. The offset argument is needed in
|
||||
// case the selection does move to the new object, and the given
|
||||
// length is not the whole length of the new node (part of it might
|
||||
// have been used to replace another node).
|
||||
select.snapshotReplaceNode = function(from, to, length, offset) {
|
||||
if (!currentSelection) return;
|
||||
|
||||
function replace(point) {
|
||||
if (from == point.node) {
|
||||
currentSelection.changed = true;
|
||||
if (length && point.offset > length) {
|
||||
point.offset -= length;
|
||||
}
|
||||
else {
|
||||
point.node = to;
|
||||
point.offset += (offset || 0);
|
||||
}
|
||||
}
|
||||
}
|
||||
replace(currentSelection.start);
|
||||
replace(currentSelection.end);
|
||||
};
|
||||
|
||||
select.snapshotMove = function(from, to, distance, relative, ifAtStart) {
|
||||
if (!currentSelection) return;
|
||||
|
||||
function move(point) {
|
||||
if (from == point.node && (!ifAtStart || point.offset == 0)) {
|
||||
currentSelection.changed = true;
|
||||
point.node = to;
|
||||
if (relative) point.offset = Math.max(0, point.offset + distance);
|
||||
else point.offset = distance;
|
||||
}
|
||||
}
|
||||
move(currentSelection.start);
|
||||
move(currentSelection.end);
|
||||
};
|
||||
|
||||
// Most functions are defined in two ways, one for the IE selection
|
||||
// model, one for the W3C one.
|
||||
if (select.ie_selection) {
|
||||
function selectionNode(win, start) {
|
||||
var range = win.document.selection.createRange();
|
||||
range.collapse(start);
|
||||
|
||||
function nodeAfter(node) {
|
||||
var found = null;
|
||||
while (!found && node) {
|
||||
found = node.nextSibling;
|
||||
node = node.parentNode;
|
||||
}
|
||||
return nodeAtStartOf(found);
|
||||
}
|
||||
|
||||
function nodeAtStartOf(node) {
|
||||
while (node && node.firstChild) node = node.firstChild;
|
||||
return {node: node, offset: 0};
|
||||
}
|
||||
|
||||
var containing = range.parentElement();
|
||||
if (!isAncestor(win.document.body, containing)) return null;
|
||||
if (!containing.firstChild) return nodeAtStartOf(containing);
|
||||
|
||||
var working = range.duplicate();
|
||||
working.moveToElementText(containing);
|
||||
working.collapse(true);
|
||||
for (var cur = containing.firstChild; cur; cur = cur.nextSibling) {
|
||||
if (cur.nodeType == 3) {
|
||||
var size = cur.nodeValue.length;
|
||||
working.move("character", size);
|
||||
}
|
||||
else {
|
||||
working.moveToElementText(cur);
|
||||
working.collapse(false);
|
||||
}
|
||||
|
||||
var dir = range.compareEndPoints("StartToStart", working);
|
||||
if (dir == 0) return nodeAfter(cur);
|
||||
if (dir == 1) continue;
|
||||
if (cur.nodeType != 3) return nodeAtStartOf(cur);
|
||||
|
||||
working.setEndPoint("StartToEnd", range);
|
||||
return {node: cur, offset: size - working.text.length};
|
||||
}
|
||||
return nodeAfter(containing);
|
||||
}
|
||||
|
||||
select.markSelection = function(win) {
|
||||
currentSelection = null;
|
||||
var sel = win.document.selection;
|
||||
if (!sel) return;
|
||||
var start = selectionNode(win, true),
|
||||
end = selectionNode(win, false);
|
||||
if (!start || !end) return;
|
||||
currentSelection = {start: start, end: end, window: win, changed: false};
|
||||
};
|
||||
|
||||
select.selectMarked = function() {
|
||||
if (!currentSelection || !currentSelection.changed) return;
|
||||
var win = currentSelection.window, doc = win.document;
|
||||
|
||||
function makeRange(point) {
|
||||
var range = doc.body.createTextRange(),
|
||||
node = point.node;
|
||||
if (!node) {
|
||||
range.moveToElementText(currentSelection.window.document.body);
|
||||
range.collapse(false);
|
||||
}
|
||||
else if (node.nodeType == 3) {
|
||||
range.moveToElementText(node.parentNode);
|
||||
var offset = point.offset;
|
||||
while (node.previousSibling) {
|
||||
node = node.previousSibling;
|
||||
offset += (node.innerText || "").length;
|
||||
}
|
||||
range.move("character", offset);
|
||||
}
|
||||
else {
|
||||
range.moveToElementText(node);
|
||||
range.collapse(true);
|
||||
}
|
||||
return range;
|
||||
}
|
||||
|
||||
var start = makeRange(currentSelection.start), end = makeRange(currentSelection.end);
|
||||
start.setEndPoint("StartToEnd", end);
|
||||
start.select();
|
||||
};
|
||||
|
||||
// Get the top-level node that one end of the cursor is inside or
|
||||
// after. Note that this returns false for 'no cursor', and null
|
||||
// for 'start of document'.
|
||||
select.selectionTopNode = function(container, start) {
|
||||
var selection = container.ownerDocument.selection;
|
||||
if (!selection) return false;
|
||||
|
||||
var range = selection.createRange(), range2 = range.duplicate();
|
||||
range.collapse(start);
|
||||
var around = range.parentElement();
|
||||
if (around && isAncestor(container, around)) {
|
||||
// Only use this node if the selection is not at its start.
|
||||
range2.moveToElementText(around);
|
||||
if (range.compareEndPoints("StartToStart", range2) == 1)
|
||||
return topLevelNodeAt(around, container);
|
||||
}
|
||||
|
||||
// Move the start of a range to the start of a node,
|
||||
// compensating for the fact that you can't call
|
||||
// moveToElementText with text nodes.
|
||||
function moveToNodeStart(range, node) {
|
||||
if (node.nodeType == 3) {
|
||||
var count = 0, cur = node.previousSibling;
|
||||
while (cur && cur.nodeType == 3) {
|
||||
count += cur.nodeValue.length;
|
||||
cur = cur.previousSibling;
|
||||
}
|
||||
if (cur) {
|
||||
try{range.moveToElementText(cur);}
|
||||
catch(e){return false;}
|
||||
range.collapse(false);
|
||||
}
|
||||
else range.moveToElementText(node.parentNode);
|
||||
if (count) range.move("character", count);
|
||||
}
|
||||
else {
|
||||
try{range.moveToElementText(node);}
|
||||
catch(e){return false;}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
// Do a binary search through the container object, comparing
|
||||
// the start of each node to the selection
|
||||
var start = 0, end = container.childNodes.length - 1;
|
||||
while (start < end) {
|
||||
var middle = Math.ceil((end + start) / 2), node = container.childNodes[middle];
|
||||
if (!node) return false; // Don't ask. IE6 manages this sometimes.
|
||||
if (!moveToNodeStart(range2, node)) return false;
|
||||
if (range.compareEndPoints("StartToStart", range2) == 1)
|
||||
start = middle;
|
||||
else
|
||||
end = middle - 1;
|
||||
}
|
||||
return container.childNodes[start] || null;
|
||||
};
|
||||
|
||||
// Place the cursor after this.start. This is only useful when
|
||||
// manually moving the cursor instead of restoring it to its old
|
||||
// position.
|
||||
select.focusAfterNode = function(node, container) {
|
||||
var range = container.ownerDocument.body.createTextRange();
|
||||
range.moveToElementText(node || container);
|
||||
range.collapse(!node);
|
||||
range.select();
|
||||
};
|
||||
|
||||
select.somethingSelected = function(win) {
|
||||
var sel = win.document.selection;
|
||||
return sel && (sel.createRange().text != "");
|
||||
};
|
||||
|
||||
function insertAtCursor(window, html) {
|
||||
var selection = window.document.selection;
|
||||
if (selection) {
|
||||
var range = selection.createRange();
|
||||
range.pasteHTML(html);
|
||||
range.collapse(false);
|
||||
range.select();
|
||||
}
|
||||
}
|
||||
|
||||
// Used to normalize the effect of the enter key, since browsers
|
||||
// do widely different things when pressing enter in designMode.
|
||||
select.insertNewlineAtCursor = function(window) {
|
||||
insertAtCursor(window, "<br>");
|
||||
};
|
||||
|
||||
select.insertTabAtCursor = function(window) {
|
||||
insertAtCursor(window, fourSpaces);
|
||||
};
|
||||
|
||||
// Get the BR node at the start of the line on which the cursor
|
||||
// currently is, and the offset into the line. Returns null as
|
||||
// node if cursor is on first line.
|
||||
select.cursorPos = function(container, start) {
|
||||
var selection = container.ownerDocument.selection;
|
||||
if (!selection) return null;
|
||||
|
||||
var topNode = select.selectionTopNode(container, start);
|
||||
while (topNode && !isBR(topNode))
|
||||
topNode = topNode.previousSibling;
|
||||
|
||||
var range = selection.createRange(), range2 = range.duplicate();
|
||||
range.collapse(start);
|
||||
if (topNode) {
|
||||
range2.moveToElementText(topNode);
|
||||
range2.collapse(false);
|
||||
}
|
||||
else {
|
||||
// When nothing is selected, we can get all kinds of funky errors here.
|
||||
try { range2.moveToElementText(container); }
|
||||
catch (e) { return null; }
|
||||
range2.collapse(true);
|
||||
}
|
||||
range.setEndPoint("StartToStart", range2);
|
||||
|
||||
return {node: topNode, offset: range.text.length};
|
||||
};
|
||||
|
||||
select.setCursorPos = function(container, from, to) {
|
||||
function rangeAt(pos) {
|
||||
var range = container.ownerDocument.body.createTextRange();
|
||||
if (!pos.node) {
|
||||
range.moveToElementText(container);
|
||||
range.collapse(true);
|
||||
}
|
||||
else {
|
||||
range.moveToElementText(pos.node);
|
||||
range.collapse(false);
|
||||
}
|
||||
range.move("character", pos.offset);
|
||||
return range;
|
||||
}
|
||||
|
||||
var range = rangeAt(from);
|
||||
if (to && to != from)
|
||||
range.setEndPoint("EndToEnd", rangeAt(to));
|
||||
range.select();
|
||||
}
|
||||
|
||||
// Some hacks for storing and re-storing the selection when the editor loses and regains focus.
|
||||
select.getBookmark = function (container) {
|
||||
var from = select.cursorPos(container, true), to = select.cursorPos(container, false);
|
||||
if (from && to) return {from: from, to: to};
|
||||
};
|
||||
|
||||
// Restore a stored selection.
|
||||
select.setBookmark = function(container, mark) {
|
||||
if (!mark) return;
|
||||
select.setCursorPos(container, mark.from, mark.to);
|
||||
};
|
||||
}
|
||||
// W3C model
|
||||
else {
|
||||
// Store start and end nodes, and offsets within these, and refer
|
||||
// back to the selection object from those nodes, so that this
|
||||
// object can be updated when the nodes are replaced before the
|
||||
// selection is restored.
|
||||
select.markSelection = function (win) {
|
||||
var selection = win.getSelection();
|
||||
if (!selection || selection.rangeCount == 0)
|
||||
return (currentSelection = null);
|
||||
var range = selection.getRangeAt(0);
|
||||
|
||||
currentSelection = {
|
||||
start: {node: range.startContainer, offset: range.startOffset},
|
||||
end: {node: range.endContainer, offset: range.endOffset},
|
||||
window: win,
|
||||
changed: false
|
||||
};
|
||||
|
||||
// We want the nodes right at the cursor, not one of their
|
||||
// ancestors with a suitable offset. This goes down the DOM tree
|
||||
// until a 'leaf' is reached (or is it *up* the DOM tree?).
|
||||
function normalize(point){
|
||||
while (point.node.nodeType != 3 && !isBR(point.node)) {
|
||||
var newNode = point.node.childNodes[point.offset] || point.node.nextSibling;
|
||||
point.offset = 0;
|
||||
while (!newNode && point.node.parentNode) {
|
||||
point.node = point.node.parentNode;
|
||||
newNode = point.node.nextSibling;
|
||||
}
|
||||
point.node = newNode;
|
||||
if (!newNode)
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
normalize(currentSelection.start);
|
||||
normalize(currentSelection.end);
|
||||
};
|
||||
|
||||
select.selectMarked = function () {
|
||||
var cs = currentSelection;
|
||||
// on webkit-based browsers, it is apparently possible that the
|
||||
// selection gets reset even when a node that is not one of the
|
||||
// endpoints get messed with. the most common situation where
|
||||
// this occurs is when a selection is deleted or overwitten. we
|
||||
// check for that here.
|
||||
function focusIssue() {
|
||||
return cs.start.node == cs.end.node && cs.start.offset == 0 && cs.end.offset == 0;
|
||||
}
|
||||
if (!cs || !(cs.changed || (webkit && focusIssue()))) return;
|
||||
var win = cs.window, range = win.document.createRange();
|
||||
|
||||
function setPoint(point, which) {
|
||||
if (point.node) {
|
||||
// Some magic to generalize the setting of the start and end
|
||||
// of a range.
|
||||
if (point.offset == 0)
|
||||
range["set" + which + "Before"](point.node);
|
||||
else
|
||||
range["set" + which](point.node, point.offset);
|
||||
}
|
||||
else {
|
||||
range.setStartAfter(win.document.body.lastChild || win.document.body);
|
||||
}
|
||||
}
|
||||
|
||||
setPoint(cs.end, "End");
|
||||
setPoint(cs.start, "Start");
|
||||
selectRange(range, win);
|
||||
};
|
||||
|
||||
// Helper for selecting a range object.
|
||||
function selectRange(range, window) {
|
||||
var selection = window.getSelection();
|
||||
selection.removeAllRanges();
|
||||
selection.addRange(range);
|
||||
};
|
||||
function selectionRange(window) {
|
||||
var selection = window.getSelection();
|
||||
if (!selection || selection.rangeCount == 0)
|
||||
return false;
|
||||
else
|
||||
return selection.getRangeAt(0);
|
||||
}
|
||||
|
||||
// Finding the top-level node at the cursor in the W3C is, as you
|
||||
// can see, quite an involved process.
|
||||
select.selectionTopNode = function(container, start) {
|
||||
var range = selectionRange(container.ownerDocument.defaultView);
|
||||
if (!range) return false;
|
||||
|
||||
var node = start ? range.startContainer : range.endContainer;
|
||||
var offset = start ? range.startOffset : range.endOffset;
|
||||
// Work around (yet another) bug in Opera's selection model.
|
||||
if (window.opera && !start && range.endContainer == container && range.endOffset == range.startOffset + 1 &&
|
||||
container.childNodes[range.startOffset] && isBR(container.childNodes[range.startOffset]))
|
||||
offset--;
|
||||
|
||||
// For text nodes, we look at the node itself if the cursor is
|
||||
// inside, or at the node before it if the cursor is at the
|
||||
// start.
|
||||
if (node.nodeType == 3){
|
||||
if (offset > 0)
|
||||
return topLevelNodeAt(node, container);
|
||||
else
|
||||
return topLevelNodeBefore(node, container);
|
||||
}
|
||||
// Occasionally, browsers will return the HTML node as
|
||||
// selection. If the offset is 0, we take the start of the frame
|
||||
// ('after null'), otherwise, we take the last node.
|
||||
else if (node.nodeName.toUpperCase() == "HTML") {
|
||||
return (offset == 1 ? null : container.lastChild);
|
||||
}
|
||||
// If the given node is our 'container', we just look up the
|
||||
// correct node by using the offset.
|
||||
else if (node == container) {
|
||||
return (offset == 0) ? null : node.childNodes[offset - 1];
|
||||
}
|
||||
// In any other case, we have a regular node. If the cursor is
|
||||
// at the end of the node, we use the node itself, if it is at
|
||||
// the start, we use the node before it, and in any other
|
||||
// case, we look up the child before the cursor and use that.
|
||||
else {
|
||||
if (offset == node.childNodes.length)
|
||||
return topLevelNodeAt(node, container);
|
||||
else if (offset == 0)
|
||||
return topLevelNodeBefore(node, container);
|
||||
else
|
||||
return topLevelNodeAt(node.childNodes[offset - 1], container);
|
||||
}
|
||||
};
|
||||
|
||||
select.focusAfterNode = function(node, container) {
|
||||
var win = container.ownerDocument.defaultView,
|
||||
range = win.document.createRange();
|
||||
range.setStartBefore(container.firstChild || container);
|
||||
// In Opera, setting the end of a range at the end of a line
|
||||
// (before a BR) will cause the cursor to appear on the next
|
||||
// line, so we set the end inside of the start node when
|
||||
// possible.
|
||||
if (node && !node.firstChild)
|
||||
range.setEndAfter(node);
|
||||
else if (node)
|
||||
range.setEnd(node, node.childNodes.length);
|
||||
else
|
||||
range.setEndBefore(container.firstChild || container);
|
||||
range.collapse(false);
|
||||
selectRange(range, win);
|
||||
};
|
||||
|
||||
select.somethingSelected = function(win) {
|
||||
var range = selectionRange(win);
|
||||
return range && !range.collapsed;
|
||||
};
|
||||
|
||||
function insertNodeAtCursor(window, node) {
|
||||
var range = selectionRange(window);
|
||||
if (!range) return;
|
||||
|
||||
range.deleteContents();
|
||||
range.insertNode(node);
|
||||
webkitLastLineHack(window.document.body);
|
||||
range = window.document.createRange();
|
||||
range.selectNode(node);
|
||||
range.collapse(false);
|
||||
selectRange(range, window);
|
||||
}
|
||||
|
||||
select.insertNewlineAtCursor = function(window) {
|
||||
insertNodeAtCursor(window, window.document.createElement("BR"));
|
||||
};
|
||||
|
||||
select.insertTabAtCursor = function(window) {
|
||||
insertNodeAtCursor(window, window.document.createTextNode(fourSpaces));
|
||||
};
|
||||
|
||||
select.cursorPos = function(container, start) {
|
||||
var range = selectionRange(window);
|
||||
if (!range) return;
|
||||
|
||||
var topNode = select.selectionTopNode(container, start);
|
||||
while (topNode && !isBR(topNode))
|
||||
topNode = topNode.previousSibling;
|
||||
|
||||
range = range.cloneRange();
|
||||
range.collapse(start);
|
||||
if (topNode)
|
||||
range.setStartAfter(topNode);
|
||||
else
|
||||
range.setStartBefore(container);
|
||||
return {node: topNode, offset: range.toString().length};
|
||||
};
|
||||
|
||||
select.setCursorPos = function(container, from, to) {
|
||||
var win = container.ownerDocument.defaultView,
|
||||
range = win.document.createRange();
|
||||
|
||||
function setPoint(node, offset, side) {
|
||||
if (offset == 0 && node && !node.nextSibling) {
|
||||
range["set" + side + "After"](node);
|
||||
return true;
|
||||
}
|
||||
|
||||
if (!node)
|
||||
node = container.firstChild;
|
||||
else
|
||||
node = node.nextSibling;
|
||||
|
||||
if (!node) return;
|
||||
|
||||
if (offset == 0) {
|
||||
range["set" + side + "Before"](node);
|
||||
return true;
|
||||
}
|
||||
|
||||
var backlog = []
|
||||
function decompose(node) {
|
||||
if (node.nodeType == 3)
|
||||
backlog.push(node);
|
||||
else
|
||||
forEach(node.childNodes, decompose);
|
||||
}
|
||||
while (true) {
|
||||
while (node && !backlog.length) {
|
||||
decompose(node);
|
||||
node = node.nextSibling;
|
||||
}
|
||||
var cur = backlog.shift();
|
||||
if (!cur) return false;
|
||||
|
||||
var length = cur.nodeValue.length;
|
||||
if (length >= offset) {
|
||||
range["set" + side](cur, offset);
|
||||
return true;
|
||||
}
|
||||
offset -= length;
|
||||
}
|
||||
}
|
||||
|
||||
to = to || from;
|
||||
if (setPoint(to.node, to.offset, "End") && setPoint(from.node, from.offset, "Start"))
|
||||
selectRange(range, win);
|
||||
};
|
||||
}
|
||||
})();
|
||||
@ -1,140 +0,0 @@
|
||||
/* String streams are the things fed to parsers (which can feed them
|
||||
* to a tokenizer if they want). They provide peek and next methods
|
||||
* for looking at the current character (next 'consumes' this
|
||||
* character, peek does not), and a get method for retrieving all the
|
||||
* text that was consumed since the last time get was called.
|
||||
*
|
||||
* An easy mistake to make is to let a StopIteration exception finish
|
||||
* the token stream while there are still characters pending in the
|
||||
* string stream (hitting the end of the buffer while parsing a
|
||||
* token). To make it easier to detect such errors, the stringstreams
|
||||
* throw an exception when this happens.
|
||||
*/
|
||||
|
||||
// Make a stringstream stream out of an iterator that returns strings.
|
||||
// This is applied to the result of traverseDOM (see codemirror.js),
|
||||
// and the resulting stream is fed to the parser.
|
||||
var stringStream = function(source){
|
||||
// String that's currently being iterated over.
|
||||
var current = "";
|
||||
// Position in that string.
|
||||
var pos = 0;
|
||||
// Accumulator for strings that have been iterated over but not
|
||||
// get()-ed yet.
|
||||
var accum = "";
|
||||
// Make sure there are more characters ready, or throw
|
||||
// StopIteration.
|
||||
function ensureChars() {
|
||||
while (pos == current.length) {
|
||||
accum += current;
|
||||
current = ""; // In case source.next() throws
|
||||
pos = 0;
|
||||
try {current = source.next();}
|
||||
catch (e) {
|
||||
if (e != StopIteration) throw e;
|
||||
else return false;
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
return {
|
||||
// Return the next character in the stream.
|
||||
peek: function() {
|
||||
if (!ensureChars()) return null;
|
||||
return current.charAt(pos);
|
||||
},
|
||||
// Get the next character, throw StopIteration if at end, check
|
||||
// for unused content.
|
||||
next: function() {
|
||||
if (!ensureChars()) {
|
||||
if (accum.length > 0)
|
||||
throw "End of stringstream reached without emptying buffer ('" + accum + "').";
|
||||
else
|
||||
throw StopIteration;
|
||||
}
|
||||
return current.charAt(pos++);
|
||||
},
|
||||
// Return the characters iterated over since the last call to
|
||||
// .get().
|
||||
get: function() {
|
||||
var temp = accum;
|
||||
accum = "";
|
||||
if (pos > 0){
|
||||
temp += current.slice(0, pos);
|
||||
current = current.slice(pos);
|
||||
pos = 0;
|
||||
}
|
||||
return temp;
|
||||
},
|
||||
// Push a string back into the stream.
|
||||
push: function(str) {
|
||||
current = current.slice(0, pos) + str + current.slice(pos);
|
||||
},
|
||||
lookAhead: function(str, consume, skipSpaces, caseInsensitive) {
|
||||
function cased(str) {return caseInsensitive ? str.toLowerCase() : str;}
|
||||
str = cased(str);
|
||||
var found = false;
|
||||
|
||||
var _accum = accum, _pos = pos;
|
||||
if (skipSpaces) this.nextWhileMatches(/[\s\u00a0]/);
|
||||
|
||||
while (true) {
|
||||
var end = pos + str.length, left = current.length - pos;
|
||||
if (end <= current.length) {
|
||||
found = str == cased(current.slice(pos, end));
|
||||
pos = end;
|
||||
break;
|
||||
}
|
||||
else if (str.slice(0, left) == cased(current.slice(pos))) {
|
||||
accum += current; current = "";
|
||||
try {current = source.next();}
|
||||
catch (e) {break;}
|
||||
pos = 0;
|
||||
str = str.slice(left);
|
||||
}
|
||||
else {
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (!(found && consume)) {
|
||||
current = accum.slice(_accum.length) + current;
|
||||
pos = _pos;
|
||||
accum = _accum;
|
||||
}
|
||||
|
||||
return found;
|
||||
},
|
||||
|
||||
// Utils built on top of the above
|
||||
more: function() {
|
||||
return this.peek() !== null;
|
||||
},
|
||||
applies: function(test) {
|
||||
var next = this.peek();
|
||||
return (next !== null && test(next));
|
||||
},
|
||||
nextWhile: function(test) {
|
||||
var next;
|
||||
while ((next = this.peek()) !== null && test(next))
|
||||
this.next();
|
||||
},
|
||||
matches: function(re) {
|
||||
var next = this.peek();
|
||||
return (next !== null && re.test(next));
|
||||
},
|
||||
nextWhileMatches: function(re) {
|
||||
var next;
|
||||
while ((next = this.peek()) !== null && re.test(next))
|
||||
this.next();
|
||||
},
|
||||
equals: function(ch) {
|
||||
return ch === this.peek();
|
||||
},
|
||||
endOfLine: function() {
|
||||
var next = this.peek();
|
||||
return next == null || next == "\n";
|
||||
}
|
||||
};
|
||||
};
|
||||
@ -1,57 +0,0 @@
|
||||
// A framework for simple tokenizers. Takes care of newlines and
|
||||
// white-space, and of getting the text from the source stream into
|
||||
// the token object. A state is a function of two arguments -- a
|
||||
// string stream and a setState function. The second can be used to
|
||||
// change the tokenizer's state, and can be ignored for stateless
|
||||
// tokenizers. This function should advance the stream over a token
|
||||
// and return a string or object containing information about the next
|
||||
// token, or null to pass and have the (new) state be called to finish
|
||||
// the token. When a string is given, it is wrapped in a {style, type}
|
||||
// object. In the resulting object, the characters consumed are stored
|
||||
// under the content property. Any whitespace following them is also
|
||||
// automatically consumed, and added to the value property. (Thus,
|
||||
// content is the actual meaningful part of the token, while value
|
||||
// contains all the text it spans.)
|
||||
|
||||
function tokenizer(source, state) {
|
||||
// Newlines are always a separate token.
|
||||
function isWhiteSpace(ch) {
|
||||
// The messy regexp is because IE's regexp matcher is of the
|
||||
// opinion that non-breaking spaces are no whitespace.
|
||||
return ch != "\n" && /^[\s\u00a0]*$/.test(ch);
|
||||
}
|
||||
|
||||
var tokenizer = {
|
||||
state: state,
|
||||
|
||||
take: function(type) {
|
||||
if (typeof(type) == "string")
|
||||
type = {style: type, type: type};
|
||||
|
||||
type.content = (type.content || "") + source.get();
|
||||
if (!/\n$/.test(type.content))
|
||||
source.nextWhile(isWhiteSpace);
|
||||
type.value = type.content + source.get();
|
||||
return type;
|
||||
},
|
||||
|
||||
next: function () {
|
||||
if (!source.more()) throw StopIteration;
|
||||
|
||||
var type;
|
||||
if (source.equals("\n")) {
|
||||
source.next();
|
||||
return this.take("whitespace");
|
||||
}
|
||||
|
||||
if (source.applies(isWhiteSpace))
|
||||
type = "whitespace";
|
||||
else
|
||||
while (!type)
|
||||
type = this.state(source, function(s) {tokenizer.state = s;});
|
||||
|
||||
return this.take(type);
|
||||
}
|
||||
};
|
||||
return tokenizer;
|
||||
}
|
||||
@ -1,175 +0,0 @@
|
||||
/* Tokenizer for JavaScript code */
|
||||
|
||||
var tokenizeJavaScript = (function() {
|
||||
// Advance the stream until the given character (not preceded by a
|
||||
// backslash) is encountered, or the end of the line is reached.
|
||||
function nextUntilUnescaped(source, end) {
|
||||
var escaped = false;
|
||||
var next;
|
||||
while (!source.endOfLine()) {
|
||||
var next = source.next();
|
||||
if (next == end && !escaped)
|
||||
return false;
|
||||
escaped = !escaped && next == "\\";
|
||||
}
|
||||
return escaped;
|
||||
}
|
||||
|
||||
// A map of JavaScript's keywords. The a/b/c keyword distinction is
|
||||
// very rough, but it gives the parser enough information to parse
|
||||
// correct code correctly (we don't care that much how we parse
|
||||
// incorrect code). The style information included in these objects
|
||||
// is used by the highlighter to pick the correct CSS style for a
|
||||
// token.
|
||||
var keywords = function(){
|
||||
function result(type, style){
|
||||
return {type: type, style: "js-" + style};
|
||||
}
|
||||
// keywords that take a parenthised expression, and then a
|
||||
// statement (if)
|
||||
var keywordA = result("keyword a", "keyword");
|
||||
// keywords that take just a statement (else)
|
||||
var keywordB = result("keyword b", "keyword");
|
||||
// keywords that optionally take an expression, and form a
|
||||
// statement (return)
|
||||
var keywordC = result("keyword c", "keyword");
|
||||
var operator = result("operator", "keyword");
|
||||
var atom = result("atom", "atom");
|
||||
return {
|
||||
"if": keywordA, "while": keywordA, "with": keywordA,
|
||||
"else": keywordB, "do": keywordB, "try": keywordB, "finally": keywordB,
|
||||
"return": keywordC, "break": keywordC, "continue": keywordC, "new": keywordC, "delete": keywordC, "throw": keywordC,
|
||||
"in": operator, "typeof": operator, "instanceof": operator,
|
||||
"var": result("var", "keyword"), "function": result("function", "keyword"), "catch": result("catch", "keyword"),
|
||||
"for": result("for", "keyword"), "switch": result("switch", "keyword"),
|
||||
"case": result("case", "keyword"), "default": result("default", "keyword"),
|
||||
"true": atom, "false": atom, "null": atom, "undefined": atom, "NaN": atom, "Infinity": atom
|
||||
};
|
||||
}();
|
||||
|
||||
// Some helper regexps
|
||||
var isOperatorChar = /[+\-*&%=<>!?|]/;
|
||||
var isHexDigit = /[0-9A-Fa-f]/;
|
||||
var isWordChar = /[\w\$_]/;
|
||||
|
||||
// Wrapper around jsToken that helps maintain parser state (whether
|
||||
// we are inside of a multi-line comment and whether the next token
|
||||
// could be a regular expression).
|
||||
function jsTokenState(inside, regexp) {
|
||||
return function(source, setState) {
|
||||
var newInside = inside;
|
||||
var type = jsToken(inside, regexp, source, function(c) {newInside = c;});
|
||||
var newRegexp = type.type == "operator" || type.type == "keyword c" || type.type.match(/^[\[{}\(,;:]$/);
|
||||
if (newRegexp != regexp || newInside != inside)
|
||||
setState(jsTokenState(newInside, newRegexp));
|
||||
return type;
|
||||
};
|
||||
}
|
||||
|
||||
// The token reader, inteded to be used by the tokenizer from
|
||||
// tokenize.js (through jsTokenState). Advances the source stream
|
||||
// over a token, and returns an object containing the type and style
|
||||
// of that token.
|
||||
function jsToken(inside, regexp, source, setInside) {
|
||||
function readHexNumber(){
|
||||
source.next(); // skip the 'x'
|
||||
source.nextWhileMatches(isHexDigit);
|
||||
return {type: "number", style: "js-atom"};
|
||||
}
|
||||
|
||||
function readNumber() {
|
||||
source.nextWhileMatches(/[0-9]/);
|
||||
if (source.equals(".")){
|
||||
source.next();
|
||||
source.nextWhileMatches(/[0-9]/);
|
||||
}
|
||||
if (source.equals("e") || source.equals("E")){
|
||||
source.next();
|
||||
if (source.equals("-"))
|
||||
source.next();
|
||||
source.nextWhileMatches(/[0-9]/);
|
||||
}
|
||||
return {type: "number", style: "js-atom"};
|
||||
}
|
||||
// Read a word, look it up in keywords. If not found, it is a
|
||||
// variable, otherwise it is a keyword of the type found.
|
||||
function readWord() {
|
||||
source.nextWhileMatches(isWordChar);
|
||||
var word = source.get();
|
||||
var known = keywords.hasOwnProperty(word) && keywords.propertyIsEnumerable(word) && keywords[word];
|
||||
return known ? {type: known.type, style: known.style, content: word} :
|
||||
{type: "variable", style: "js-variable", content: word};
|
||||
}
|
||||
function readRegexp() {
|
||||
nextUntilUnescaped(source, "/");
|
||||
source.nextWhileMatches(/[gi]/);
|
||||
return {type: "regexp", style: "js-string"};
|
||||
}
|
||||
// Mutli-line comments are tricky. We want to return the newlines
|
||||
// embedded in them as regular newline tokens, and then continue
|
||||
// returning a comment token for every line of the comment. So
|
||||
// some state has to be saved (inside) to indicate whether we are
|
||||
// inside a /* */ sequence.
|
||||
function readMultilineComment(start){
|
||||
var newInside = "/*";
|
||||
var maybeEnd = (start == "*");
|
||||
while (true) {
|
||||
if (source.endOfLine())
|
||||
break;
|
||||
var next = source.next();
|
||||
if (next == "/" && maybeEnd){
|
||||
newInside = null;
|
||||
break;
|
||||
}
|
||||
maybeEnd = (next == "*");
|
||||
}
|
||||
setInside(newInside);
|
||||
return {type: "comment", style: "js-comment"};
|
||||
}
|
||||
function readOperator() {
|
||||
source.nextWhileMatches(isOperatorChar);
|
||||
return {type: "operator", style: "js-operator"};
|
||||
}
|
||||
function readString(quote) {
|
||||
var endBackSlash = nextUntilUnescaped(source, quote);
|
||||
setInside(endBackSlash ? quote : null);
|
||||
return {type: "string", style: "js-string"};
|
||||
}
|
||||
|
||||
// Fetch the next token. Dispatches on first character in the
|
||||
// stream, or first two characters when the first is a slash.
|
||||
if (inside == "\"" || inside == "'")
|
||||
return readString(inside);
|
||||
var ch = source.next();
|
||||
if (inside == "/*")
|
||||
return readMultilineComment(ch);
|
||||
else if (ch == "\"" || ch == "'")
|
||||
return readString(ch);
|
||||
// with punctuation, the type of the token is the symbol itself
|
||||
else if (/[\[\]{}\(\),;\:\.]/.test(ch))
|
||||
return {type: ch, style: "js-punctuation"};
|
||||
else if (ch == "0" && (source.equals("x") || source.equals("X")))
|
||||
return readHexNumber();
|
||||
else if (/[0-9]/.test(ch))
|
||||
return readNumber();
|
||||
else if (ch == "/"){
|
||||
if (source.equals("*"))
|
||||
{ source.next(); return readMultilineComment(ch); }
|
||||
else if (source.equals("/"))
|
||||
{ nextUntilUnescaped(source, null); return {type: "comment", style: "js-comment"};}
|
||||
else if (regexp)
|
||||
return readRegexp();
|
||||
else
|
||||
return readOperator();
|
||||
}
|
||||
else if (isOperatorChar.test(ch))
|
||||
return readOperator();
|
||||
else
|
||||
return readWord();
|
||||
}
|
||||
|
||||
// The external interface to the tokenizer.
|
||||
return function(source, startState) {
|
||||
return tokenizer(source, startState || jsTokenState(false, true));
|
||||
};
|
||||
})();
|
||||
@ -1,410 +0,0 @@
|
||||
/**
|
||||
* Storage and control for undo information within a CodeMirror
|
||||
* editor. 'Why on earth is such a complicated mess required for
|
||||
* that?', I hear you ask. The goal, in implementing this, was to make
|
||||
* the complexity of storing and reverting undo information depend
|
||||
* only on the size of the edited or restored content, not on the size
|
||||
* of the whole document. This makes it necessary to use a kind of
|
||||
* 'diff' system, which, when applied to a DOM tree, causes some
|
||||
* complexity and hackery.
|
||||
*
|
||||
* In short, the editor 'touches' BR elements as it parses them, and
|
||||
* the History stores these. When nothing is touched in commitDelay
|
||||
* milliseconds, the changes are committed: It goes over all touched
|
||||
* nodes, throws out the ones that did not change since last commit or
|
||||
* are no longer in the document, and assembles the rest into zero or
|
||||
* more 'chains' -- arrays of adjacent lines. Links back to these
|
||||
* chains are added to the BR nodes, while the chain that previously
|
||||
* spanned these nodes is added to the undo history. Undoing a change
|
||||
* means taking such a chain off the undo history, restoring its
|
||||
* content (text is saved per line) and linking it back into the
|
||||
* document.
|
||||
*/
|
||||
|
||||
// A history object needs to know about the DOM container holding the
|
||||
// document, the maximum amount of undo levels it should store, the
|
||||
// delay (of no input) after which it commits a set of changes, and,
|
||||
// unfortunately, the 'parent' window -- a window that is not in
|
||||
// designMode, and on which setTimeout works in every browser.
|
||||
function History(container, maxDepth, commitDelay, editor) {
|
||||
this.container = container;
|
||||
this.maxDepth = maxDepth; this.commitDelay = commitDelay;
|
||||
this.editor = editor; this.parent = editor.parent;
|
||||
// This line object represents the initial, empty editor.
|
||||
var initial = {text: "", from: null, to: null};
|
||||
// As the borders between lines are represented by BR elements, the
|
||||
// start of the first line and the end of the last one are
|
||||
// represented by null. Since you can not store any properties
|
||||
// (links to line objects) in null, these properties are used in
|
||||
// those cases.
|
||||
this.first = initial; this.last = initial;
|
||||
// Similarly, a 'historyTouched' property is added to the BR in
|
||||
// front of lines that have already been touched, and 'firstTouched'
|
||||
// is used for the first line.
|
||||
this.firstTouched = false;
|
||||
// History is the set of committed changes, touched is the set of
|
||||
// nodes touched since the last commit.
|
||||
this.history = []; this.redoHistory = []; this.touched = [];
|
||||
}
|
||||
|
||||
History.prototype = {
|
||||
// Schedule a commit (if no other touches come in for commitDelay
|
||||
// milliseconds).
|
||||
scheduleCommit: function() {
|
||||
var self = this;
|
||||
this.parent.clearTimeout(this.commitTimeout);
|
||||
this.commitTimeout = this.parent.setTimeout(function(){self.tryCommit();}, this.commitDelay);
|
||||
},
|
||||
|
||||
// Mark a node as touched. Null is a valid argument.
|
||||
touch: function(node) {
|
||||
this.setTouched(node);
|
||||
this.scheduleCommit();
|
||||
},
|
||||
|
||||
// Undo the last change.
|
||||
undo: function() {
|
||||
// Make sure pending changes have been committed.
|
||||
this.commit();
|
||||
|
||||
if (this.history.length) {
|
||||
// Take the top diff from the history, apply it, and store its
|
||||
// shadow in the redo history.
|
||||
var item = this.history.pop();
|
||||
this.redoHistory.push(this.updateTo(item, "applyChain"));
|
||||
this.notifyEnvironment();
|
||||
return this.chainNode(item);
|
||||
}
|
||||
},
|
||||
|
||||
// Redo the last undone change.
|
||||
redo: function() {
|
||||
this.commit();
|
||||
if (this.redoHistory.length) {
|
||||
// The inverse of undo, basically.
|
||||
var item = this.redoHistory.pop();
|
||||
this.addUndoLevel(this.updateTo(item, "applyChain"));
|
||||
this.notifyEnvironment();
|
||||
return this.chainNode(item);
|
||||
}
|
||||
},
|
||||
|
||||
clear: function() {
|
||||
this.history = [];
|
||||
this.redoHistory = [];
|
||||
},
|
||||
|
||||
// Ask for the size of the un/redo histories.
|
||||
historySize: function() {
|
||||
return {undo: this.history.length, redo: this.redoHistory.length};
|
||||
},
|
||||
|
||||
// Push a changeset into the document.
|
||||
push: function(from, to, lines) {
|
||||
var chain = [];
|
||||
for (var i = 0; i < lines.length; i++) {
|
||||
var end = (i == lines.length - 1) ? to : this.container.ownerDocument.createElement("BR");
|
||||
chain.push({from: from, to: end, text: cleanText(lines[i])});
|
||||
from = end;
|
||||
}
|
||||
this.pushChains([chain], from == null && to == null);
|
||||
this.notifyEnvironment();
|
||||
},
|
||||
|
||||
pushChains: function(chains, doNotHighlight) {
|
||||
this.commit(doNotHighlight);
|
||||
this.addUndoLevel(this.updateTo(chains, "applyChain"));
|
||||
this.redoHistory = [];
|
||||
},
|
||||
|
||||
// Retrieve a DOM node from a chain (for scrolling to it after undo/redo).
|
||||
chainNode: function(chains) {
|
||||
for (var i = 0; i < chains.length; i++) {
|
||||
var start = chains[i][0], node = start && (start.from || start.to);
|
||||
if (node) return node;
|
||||
}
|
||||
},
|
||||
|
||||
// Clear the undo history, make the current document the start
|
||||
// position.
|
||||
reset: function() {
|
||||
this.history = []; this.redoHistory = [];
|
||||
},
|
||||
|
||||
textAfter: function(br) {
|
||||
return this.after(br).text;
|
||||
},
|
||||
|
||||
nodeAfter: function(br) {
|
||||
return this.after(br).to;
|
||||
},
|
||||
|
||||
nodeBefore: function(br) {
|
||||
return this.before(br).from;
|
||||
},
|
||||
|
||||
// Commit unless there are pending dirty nodes.
|
||||
tryCommit: function() {
|
||||
if (!window.History) return; // Stop when frame has been unloaded
|
||||
if (this.editor.highlightDirty()) this.commit(true);
|
||||
else this.scheduleCommit();
|
||||
},
|
||||
|
||||
// Check whether the touched nodes hold any changes, if so, commit
|
||||
// them.
|
||||
commit: function(doNotHighlight) {
|
||||
this.parent.clearTimeout(this.commitTimeout);
|
||||
// Make sure there are no pending dirty nodes.
|
||||
if (!doNotHighlight) this.editor.highlightDirty(true);
|
||||
// Build set of chains.
|
||||
var chains = this.touchedChains(), self = this;
|
||||
|
||||
if (chains.length) {
|
||||
this.addUndoLevel(this.updateTo(chains, "linkChain"));
|
||||
this.redoHistory = [];
|
||||
this.notifyEnvironment();
|
||||
}
|
||||
},
|
||||
|
||||
// [ end of public interface ]
|
||||
|
||||
// Update the document with a given set of chains, return its
|
||||
// shadow. updateFunc should be "applyChain" or "linkChain". In the
|
||||
// second case, the chains are taken to correspond the the current
|
||||
// document, and only the state of the line data is updated. In the
|
||||
// first case, the content of the chains is also pushed iinto the
|
||||
// document.
|
||||
updateTo: function(chains, updateFunc) {
|
||||
var shadows = [], dirty = [];
|
||||
for (var i = 0; i < chains.length; i++) {
|
||||
shadows.push(this.shadowChain(chains[i]));
|
||||
dirty.push(this[updateFunc](chains[i]));
|
||||
}
|
||||
if (updateFunc == "applyChain")
|
||||
this.notifyDirty(dirty);
|
||||
return shadows;
|
||||
},
|
||||
|
||||
// Notify the editor that some nodes have changed.
|
||||
notifyDirty: function(nodes) {
|
||||
forEach(nodes, method(this.editor, "addDirtyNode"))
|
||||
this.editor.scheduleHighlight();
|
||||
},
|
||||
|
||||
notifyEnvironment: function() {
|
||||
// Used by the line-wrapping line-numbering code.
|
||||
if (window.frameElement && window.frameElement.CodeMirror.updateNumbers)
|
||||
window.frameElement.CodeMirror.updateNumbers();
|
||||
if (this.onChange) this.onChange();
|
||||
},
|
||||
|
||||
// Link a chain into the DOM nodes (or the first/last links for null
|
||||
// nodes).
|
||||
linkChain: function(chain) {
|
||||
for (var i = 0; i < chain.length; i++) {
|
||||
var line = chain[i];
|
||||
if (line.from) line.from.historyAfter = line;
|
||||
else this.first = line;
|
||||
if (line.to) line.to.historyBefore = line;
|
||||
else this.last = line;
|
||||
}
|
||||
},
|
||||
|
||||
// Get the line object after/before a given node.
|
||||
after: function(node) {
|
||||
return node ? node.historyAfter : this.first;
|
||||
},
|
||||
before: function(node) {
|
||||
return node ? node.historyBefore : this.last;
|
||||
},
|
||||
|
||||
// Mark a node as touched if it has not already been marked.
|
||||
setTouched: function(node) {
|
||||
if (node) {
|
||||
if (!node.historyTouched) {
|
||||
this.touched.push(node);
|
||||
node.historyTouched = true;
|
||||
}
|
||||
}
|
||||
else {
|
||||
this.firstTouched = true;
|
||||
}
|
||||
},
|
||||
|
||||
// Store a new set of undo info, throw away info if there is more of
|
||||
// it than allowed.
|
||||
addUndoLevel: function(diffs) {
|
||||
this.history.push(diffs);
|
||||
if (this.history.length > this.maxDepth)
|
||||
this.history.shift();
|
||||
},
|
||||
|
||||
// Build chains from a set of touched nodes.
|
||||
touchedChains: function() {
|
||||
var self = this;
|
||||
|
||||
// The temp system is a crummy hack to speed up determining
|
||||
// whether a (currently touched) node has a line object associated
|
||||
// with it. nullTemp is used to store the object for the first
|
||||
// line, other nodes get it stored in their historyTemp property.
|
||||
var nullTemp = null;
|
||||
function temp(node) {return node ? node.historyTemp : nullTemp;}
|
||||
function setTemp(node, line) {
|
||||
if (node) node.historyTemp = line;
|
||||
else nullTemp = line;
|
||||
}
|
||||
|
||||
function buildLine(node) {
|
||||
var text = [];
|
||||
for (var cur = node ? node.nextSibling : self.container.firstChild;
|
||||
cur && !isBR(cur); cur = cur.nextSibling)
|
||||
if (cur.currentText) text.push(cur.currentText);
|
||||
return {from: node, to: cur, text: cleanText(text.join(""))};
|
||||
}
|
||||
|
||||
// Filter out unchanged lines and nodes that are no longer in the
|
||||
// document. Build up line objects for remaining nodes.
|
||||
var lines = [];
|
||||
if (self.firstTouched) self.touched.push(null);
|
||||
forEach(self.touched, function(node) {
|
||||
if (node && node.parentNode != self.container) return;
|
||||
|
||||
if (node) node.historyTouched = false;
|
||||
else self.firstTouched = false;
|
||||
|
||||
var line = buildLine(node), shadow = self.after(node);
|
||||
if (!shadow || shadow.text != line.text || shadow.to != line.to) {
|
||||
lines.push(line);
|
||||
setTemp(node, line);
|
||||
}
|
||||
});
|
||||
|
||||
// Get the BR element after/before the given node.
|
||||
function nextBR(node, dir) {
|
||||
var link = dir + "Sibling", search = node[link];
|
||||
while (search && !isBR(search))
|
||||
search = search[link];
|
||||
return search;
|
||||
}
|
||||
|
||||
// Assemble line objects into chains by scanning the DOM tree
|
||||
// around them.
|
||||
var chains = []; self.touched = [];
|
||||
forEach(lines, function(line) {
|
||||
// Note that this makes the loop skip line objects that have
|
||||
// been pulled into chains by lines before them.
|
||||
if (!temp(line.from)) return;
|
||||
|
||||
var chain = [], curNode = line.from, safe = true;
|
||||
// Put any line objects (referred to by temp info) before this
|
||||
// one on the front of the array.
|
||||
while (true) {
|
||||
var curLine = temp(curNode);
|
||||
if (!curLine) {
|
||||
if (safe) break;
|
||||
else curLine = buildLine(curNode);
|
||||
}
|
||||
chain.unshift(curLine);
|
||||
setTemp(curNode, null);
|
||||
if (!curNode) break;
|
||||
safe = self.after(curNode);
|
||||
curNode = nextBR(curNode, "previous");
|
||||
}
|
||||
curNode = line.to; safe = self.before(line.from);
|
||||
// Add lines after this one at end of array.
|
||||
while (true) {
|
||||
if (!curNode) break;
|
||||
var curLine = temp(curNode);
|
||||
if (!curLine) {
|
||||
if (safe) break;
|
||||
else curLine = buildLine(curNode);
|
||||
}
|
||||
chain.push(curLine);
|
||||
setTemp(curNode, null);
|
||||
safe = self.before(curNode);
|
||||
curNode = nextBR(curNode, "next");
|
||||
}
|
||||
chains.push(chain);
|
||||
});
|
||||
|
||||
return chains;
|
||||
},
|
||||
|
||||
// Find the 'shadow' of a given chain by following the links in the
|
||||
// DOM nodes at its start and end.
|
||||
shadowChain: function(chain) {
|
||||
var shadows = [], next = this.after(chain[0].from), end = chain[chain.length - 1].to;
|
||||
while (true) {
|
||||
shadows.push(next);
|
||||
var nextNode = next.to;
|
||||
if (!nextNode || nextNode == end)
|
||||
break;
|
||||
else
|
||||
next = nextNode.historyAfter || this.before(end);
|
||||
// (The this.before(end) is a hack -- FF sometimes removes
|
||||
// properties from BR nodes, in which case the best we can hope
|
||||
// for is to not break.)
|
||||
}
|
||||
return shadows;
|
||||
},
|
||||
|
||||
// Update the DOM tree to contain the lines specified in a given
|
||||
// chain, link this chain into the DOM nodes.
|
||||
applyChain: function(chain) {
|
||||
// Some attempt is made to prevent the cursor from jumping
|
||||
// randomly when an undo or redo happens. It still behaves a bit
|
||||
// strange sometimes.
|
||||
var cursor = select.cursorPos(this.container, false), self = this;
|
||||
|
||||
// Remove all nodes in the DOM tree between from and to (null for
|
||||
// start/end of container).
|
||||
function removeRange(from, to) {
|
||||
var pos = from ? from.nextSibling : self.container.firstChild;
|
||||
while (pos != to) {
|
||||
var temp = pos.nextSibling;
|
||||
removeElement(pos);
|
||||
pos = temp;
|
||||
}
|
||||
}
|
||||
|
||||
var start = chain[0].from, end = chain[chain.length - 1].to;
|
||||
// Clear the space where this change has to be made.
|
||||
removeRange(start, end);
|
||||
|
||||
// Insert the content specified by the chain into the DOM tree.
|
||||
for (var i = 0; i < chain.length; i++) {
|
||||
var line = chain[i];
|
||||
// The start and end of the space are already correct, but BR
|
||||
// tags inside it have to be put back.
|
||||
if (i > 0)
|
||||
self.container.insertBefore(line.from, end);
|
||||
|
||||
// Add the text.
|
||||
var node = makePartSpan(fixSpaces(line.text), this.container.ownerDocument);
|
||||
self.container.insertBefore(node, end);
|
||||
// See if the cursor was on this line. Put it back, adjusting
|
||||
// for changed line length, if it was.
|
||||
if (cursor && cursor.node == line.from) {
|
||||
var cursordiff = 0;
|
||||
var prev = this.after(line.from);
|
||||
if (prev && i == chain.length - 1) {
|
||||
// Only adjust if the cursor is after the unchanged part of
|
||||
// the line.
|
||||
for (var match = 0; match < cursor.offset &&
|
||||
line.text.charAt(match) == prev.text.charAt(match); match++);
|
||||
if (cursor.offset > match)
|
||||
cursordiff = line.text.length - prev.text.length;
|
||||
}
|
||||
select.setCursorPos(this.container, {node: line.from, offset: Math.max(0, cursor.offset + cursordiff)});
|
||||
}
|
||||
// Cursor was in removed line, this is last new line.
|
||||
else if (cursor && (i == chain.length - 1) && cursor.node && cursor.node.parentNode != this.container) {
|
||||
select.setCursorPos(this.container, {node: line.from, offset: line.text.length});
|
||||
}
|
||||
}
|
||||
|
||||
// Anchor the chain in the DOM tree.
|
||||
this.linkChain(chain);
|
||||
return start;
|
||||
}
|
||||
};
|
||||
@ -1,130 +0,0 @@
|
||||
/* A few useful utility functions. */
|
||||
|
||||
// Capture a method on an object.
|
||||
function method(obj, name) {
|
||||
return function() {obj[name].apply(obj, arguments);};
|
||||
}
|
||||
|
||||
// The value used to signal the end of a sequence in iterators.
|
||||
var StopIteration = {toString: function() {return "StopIteration"}};
|
||||
|
||||
// Apply a function to each element in a sequence.
|
||||
function forEach(iter, f) {
|
||||
if (iter.next) {
|
||||
try {while (true) f(iter.next());}
|
||||
catch (e) {if (e != StopIteration) throw e;}
|
||||
}
|
||||
else {
|
||||
for (var i = 0; i < iter.length; i++)
|
||||
f(iter[i]);
|
||||
}
|
||||
}
|
||||
|
||||
// Map a function over a sequence, producing an array of results.
|
||||
function map(iter, f) {
|
||||
var accum = [];
|
||||
forEach(iter, function(val) {accum.push(f(val));});
|
||||
return accum;
|
||||
}
|
||||
|
||||
// Create a predicate function that tests a string againsts a given
|
||||
// regular expression. No longer used but might be used by 3rd party
|
||||
// parsers.
|
||||
function matcher(regexp){
|
||||
return function(value){return regexp.test(value);};
|
||||
}
|
||||
|
||||
// Test whether a DOM node has a certain CSS class. Much faster than
|
||||
// the MochiKit equivalent, for some reason.
|
||||
function hasClass(element, className){
|
||||
var classes = element.className;
|
||||
return classes && new RegExp("(^| )" + className + "($| )").test(classes);
|
||||
}
|
||||
|
||||
// Insert a DOM node after another node.
|
||||
function insertAfter(newNode, oldNode) {
|
||||
var parent = oldNode.parentNode;
|
||||
parent.insertBefore(newNode, oldNode.nextSibling);
|
||||
return newNode;
|
||||
}
|
||||
|
||||
function removeElement(node) {
|
||||
if (node.parentNode)
|
||||
node.parentNode.removeChild(node);
|
||||
}
|
||||
|
||||
function clearElement(node) {
|
||||
while (node.firstChild)
|
||||
node.removeChild(node.firstChild);
|
||||
}
|
||||
|
||||
// Check whether a node is contained in another one.
|
||||
function isAncestor(node, child) {
|
||||
while (child = child.parentNode) {
|
||||
if (node == child)
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
// The non-breaking space character.
|
||||
var nbsp = "\u00a0";
|
||||
var matching = {"{": "}", "[": "]", "(": ")",
|
||||
"}": "{", "]": "[", ")": "("};
|
||||
|
||||
// Standardize a few unportable event properties.
|
||||
function normalizeEvent(event) {
|
||||
if (!event.stopPropagation) {
|
||||
event.stopPropagation = function() {this.cancelBubble = true;};
|
||||
event.preventDefault = function() {this.returnValue = false;};
|
||||
}
|
||||
if (!event.stop) {
|
||||
event.stop = function() {
|
||||
this.stopPropagation();
|
||||
this.preventDefault();
|
||||
};
|
||||
}
|
||||
|
||||
if (event.type == "keypress") {
|
||||
event.code = (event.charCode == null) ? event.keyCode : event.charCode;
|
||||
event.character = String.fromCharCode(event.code);
|
||||
}
|
||||
return event;
|
||||
}
|
||||
|
||||
// Portably register event handlers.
|
||||
function addEventHandler(node, type, handler, removeFunc) {
|
||||
function wrapHandler(event) {
|
||||
handler(normalizeEvent(event || window.event));
|
||||
}
|
||||
if (typeof node.addEventListener == "function") {
|
||||
node.addEventListener(type, wrapHandler, false);
|
||||
if (removeFunc) return function() {node.removeEventListener(type, wrapHandler, false);};
|
||||
}
|
||||
else {
|
||||
node.attachEvent("on" + type, wrapHandler);
|
||||
if (removeFunc) return function() {node.detachEvent("on" + type, wrapHandler);};
|
||||
}
|
||||
}
|
||||
|
||||
function nodeText(node) {
|
||||
return node.textContent || node.innerText || node.nodeValue || "";
|
||||
}
|
||||
|
||||
function nodeTop(node) {
|
||||
var top = 0;
|
||||
while (node.offsetParent) {
|
||||
top += node.offsetTop;
|
||||
node = node.offsetParent;
|
||||
}
|
||||
return top;
|
||||
}
|
||||
|
||||
function isBR(node) {
|
||||
var nn = node.nodeName;
|
||||
return nn == "BR" || nn == "br";
|
||||
}
|
||||
function isSpan(node) {
|
||||
var nn = node.nodeName;
|
||||
return nn == "SPAN" || nn == "span";
|
||||
}
|
||||
@ -1,51 +0,0 @@
|
||||
.editbox {
|
||||
margin: .4em;
|
||||
padding: 0;
|
||||
font-family: monospace;
|
||||
font-size: 10pt;
|
||||
color: black;
|
||||
}
|
||||
|
||||
.editbox p {
|
||||
margin: 0;
|
||||
}
|
||||
|
||||
span.xml-tagname {
|
||||
color: #A0B;
|
||||
}
|
||||
|
||||
span.xml-attribute {
|
||||
color: #281;
|
||||
}
|
||||
|
||||
span.xml-punctuation {
|
||||
color: black;
|
||||
}
|
||||
|
||||
span.xml-attname {
|
||||
color: #00F;
|
||||
}
|
||||
|
||||
span.xml-comment {
|
||||
color: #A70;
|
||||
}
|
||||
|
||||
span.xml-cdata {
|
||||
color: #48A;
|
||||
}
|
||||
|
||||
span.xml-processing {
|
||||
color: #999;
|
||||
}
|
||||
|
||||
span.xml-entity {
|
||||
color: #A22;
|
||||
}
|
||||
|
||||
span.xml-error {
|
||||
color: #F00;
|
||||
}
|
||||
|
||||
span.xml-text {
|
||||
color: black;
|
||||
}
|
||||
@ -1,87 +0,0 @@
|
||||
body {
|
||||
font-family: "Trebuchet MS", Helvetica, sans-serif;
|
||||
}
|
||||
|
||||
p.infotext {
|
||||
color: #afafaf;
|
||||
font-size: 10pt;
|
||||
}
|
||||
|
||||
/* Left will inherit from right (so we don't need to duplicate code) */
|
||||
.github-fork-ribbon {
|
||||
/* The right and left classes determine the side we attach our banner to */
|
||||
position: absolute;
|
||||
/* Add a bit of padding to give some substance outside the "stitching" */
|
||||
padding: 2px 0;
|
||||
/* Set the base colour */
|
||||
background-color: #66C5E4;
|
||||
/* Set a gradient: transparent black at the top to almost-transparent black at the bottom */
|
||||
background-image: -webkit-gradient(linear, left top, left bottom, from(rgba(0, 0, 0, 0)),
|
||||
to(rgba(0, 0, 0, 0.15)));
|
||||
background-image: -webkit-linear-gradient(top, rgba(0, 0, 0, 0),
|
||||
rgba(0, 0, 0, 0.15));
|
||||
background-image: -moz-linear-gradient(top, rgba(0, 0, 0, 0),
|
||||
rgba(0, 0, 0, 0.15));
|
||||
background-image: -ms-linear-gradient(top, rgba(0, 0, 0, 0),
|
||||
rgba(0, 0, 0, 0.15));
|
||||
background-image: -o-linear-gradient(top, rgba(0, 0, 0, 0),
|
||||
rgba(0, 0, 0, 0.15));
|
||||
background-image: linear-gradient(to bottom, rgba(0, 0, 0, 0),
|
||||
rgba(0, 0, 0, 0.15));
|
||||
/* Add a drop shadow */
|
||||
-webkit-box-shadow: 0 2px 3px 0 rgba(0, 0, 0, 0.5);
|
||||
-moz-box-shadow: 0 2px 3px 0 rgba(0, 0, 0, 0.5);
|
||||
box-shadow: 0 2px 3px 0 rgba(0, 0, 0, 0.5);
|
||||
z-index: 9999;
|
||||
pointer-events: auto;
|
||||
}
|
||||
|
||||
.github-fork-ribbon a,.github-fork-ribbon a:hover {
|
||||
/* Set the font */
|
||||
font: 700 13px "Helvetica Neue", Helvetica, Arial, sans-serif;
|
||||
color: #fff;
|
||||
/* Set the text properties */
|
||||
text-decoration: none;
|
||||
text-shadow: 0 -1px rgba(0, 0, 0, 0.5);
|
||||
text-align: center;
|
||||
/* Set the geometry. If you fiddle with these you'll also need
|
||||
to tweak the top and right values in .github-fork-ribbon. */
|
||||
width: 200px;
|
||||
line-height: 20px;
|
||||
/* Set the layout properties */
|
||||
display: inline-block;
|
||||
padding: 2px 0;
|
||||
/* Add "stitching" effect */
|
||||
border-width: 1px 0;
|
||||
border-style: dotted;
|
||||
border-color: #fff;
|
||||
border-color: rgba(255, 255, 255, 0.7);
|
||||
}
|
||||
|
||||
.github-fork-ribbon-wrapper {
|
||||
width: 150px;
|
||||
height: 150px;
|
||||
position: absolute;
|
||||
overflow: hidden;
|
||||
top: 0;
|
||||
z-index: 9999;
|
||||
pointer-events: none;
|
||||
}
|
||||
|
||||
.github-fork-ribbon-wrapper.fixed {
|
||||
position: fixed;
|
||||
}
|
||||
|
||||
.github-fork-ribbon-wrapper.right {
|
||||
right: 0;
|
||||
}
|
||||
|
||||
.github-fork-ribbon-wrapper.right .github-fork-ribbon {
|
||||
top: 42px;
|
||||
right: -43px;
|
||||
-webkit-transform: rotate(45deg);
|
||||
-moz-transform: rotate(45deg);
|
||||
-ms-transform: rotate(45deg);
|
||||
-o-transform: rotate(45deg);
|
||||
transform: rotate(45deg);
|
||||
}
|
||||
@ -1,24 +0,0 @@
|
||||
#### Use two appenders, one to log to console, another to log to a file
|
||||
log4j.rootCategory=ERROR,AR
|
||||
|
||||
#### Second appender writes to a file
|
||||
#log4j.appender.stdout=org.apache.log4j.ConsoleAppender
|
||||
#log4j.appender.stdout.Threshold=OFF
|
||||
#log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
|
||||
#log4j.appender.stdout.layout.ConversionPattern=%d{dd/MM/yyyy HH:mm:ss} %p %t %c - %m%n
|
||||
|
||||
log4j.logger.AnalysisLogger=AR
|
||||
log4j.appender.AR=org.apache.log4j.RollingFileAppender
|
||||
log4j.appender.AR.Threshold=TRACE
|
||||
log4j.appender.AR.File=logs/analysis/Analysis.log
|
||||
log4j.appender.AR.MaxFileSize=50000KB
|
||||
log4j.appender.AR.MaxBackupIndex=2
|
||||
log4j.appender.AR.layout=org.apache.log4j.PatternLayout
|
||||
log4j.appender.AR.layout.ConversionPattern=%d{dd/MM/yyyy HH:mm:ss} %p %t %c - %m%n
|
||||
|
||||
#### Third appender writes to a file
|
||||
log4j.logger.org.hibernate=H
|
||||
log4j.appender.H=org.apache.log4j.AsyncAppender
|
||||
log4j.appender.H.Threshold=OFF
|
||||
log4j.appender.H.layout=org.apache.log4j.PatternLayout
|
||||
log4j.appender.H.layout.ConversionPattern=%d{dd/MM/yyyy HH:mm:ss} %p %t %c - %m%n
|
||||
@ -1,85 +0,0 @@
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" elementFormDefault="qualified" attributeFormDefault="qualified">
|
||||
<xs:element name="GPAlgorithmDescription">
|
||||
<xs:annotation>
|
||||
<xs:documentation>Comment describing your root element</xs:documentation>
|
||||
</xs:annotation>
|
||||
<xs:complexType>
|
||||
<xs:sequence>
|
||||
<xs:element name="algorithmWorkspaceLocation" type="xs:anyURI">
|
||||
<xs:annotation>
|
||||
<xs:documentation>URL pointing to the workspace root</xs:documentation>
|
||||
</xs:annotation>
|
||||
</xs:element>
|
||||
<xs:element name="algorithmContainerLocation" type="xs:anyURI">
|
||||
<xs:annotation>
|
||||
<xs:documentation>URL pointing to the algorithm; relative to the workspace root. If appropriate, this location can point to some location within the container</xs:documentation>
|
||||
</xs:annotation>
|
||||
</xs:element>
|
||||
<xs:element name="algorithmLocation" type="xs:anyURI" minOccurs="0">
|
||||
<xs:annotation>
|
||||
<xs:documentation>Optional URL pointing to a location within the algorithm container. This is e.g. useful to acces tools inside ArcGIS Toolboxes</xs:documentation>
|
||||
</xs:annotation>
|
||||
</xs:element>
|
||||
<xs:element name="algorithmContainerURN" type="xs:anyURI">
|
||||
<xs:annotation>
|
||||
<xs:documentation>URN referencing the specific container, e.g. urn:n52:wps:algorithmcontainer:arctoolbox:9.3</xs:documentation>
|
||||
</xs:annotation>
|
||||
</xs:element>
|
||||
<xs:element name="processingSystemURN" type="xs:anyURI" maxOccurs="unbounded">
|
||||
<xs:annotation>
|
||||
<xs:documentation>URN referencing a required processing backend, e.g. urn:n52:wps:gpsystem:arcgis:9.3</xs:documentation>
|
||||
</xs:annotation>
|
||||
</xs:element>
|
||||
<xs:element name="algorithmParameters">
|
||||
<xs:annotation>
|
||||
<xs:documentation>A collection of the algorithm parameters</xs:documentation>
|
||||
</xs:annotation>
|
||||
<xs:complexType>
|
||||
<xs:sequence>
|
||||
<xs:element name="parameter" type="AlgorithmParameterType" maxOccurs="unbounded">
|
||||
<xs:annotation>
|
||||
<xs:documentation>The tool's parameters</xs:documentation>
|
||||
</xs:annotation>
|
||||
</xs:element>
|
||||
</xs:sequence>
|
||||
<xs:attribute name="sequential" type="xs:boolean">
|
||||
<xs:annotation>
|
||||
<xs:documentation>If true, this tool's parameters are indexed through their position as integers. Otherwise, the mapping from the ows:Identifier to the respective LegacyID is done via name strings.</xs:documentation>
|
||||
</xs:annotation>
|
||||
</xs:attribute>
|
||||
</xs:complexType>
|
||||
</xs:element>
|
||||
</xs:sequence>
|
||||
</xs:complexType>
|
||||
</xs:element>
|
||||
<!-- ========================================================================== -->
|
||||
<xs:complexType name="AlgorithmParameterType">
|
||||
<xs:sequence>
|
||||
<xs:element name="prefixString" type="xs:string" minOccurs="0"/>
|
||||
<xs:element name="suffixString" type="xs:string" minOccurs="0"/>
|
||||
<xs:element name="separatorString" type="xs:string" minOccurs="0"/>
|
||||
<xs:choice>
|
||||
<xs:annotation>
|
||||
<xs:documentation>The Legacy ID by which the parameters are defined in the Legacy environment. Use legacyIntID for sequential parameters, legacyStrindID for parameters name strings</xs:documentation>
|
||||
</xs:annotation>
|
||||
<xs:element name="legacyIntID" type="legacyIntIDType"/>
|
||||
<xs:element name="legacyStrindID" type="legacyStrindIDType"/>
|
||||
</xs:choice>
|
||||
<xs:element name="wpsInputID" type="xs:string" minOccurs="0"/>
|
||||
<xs:element name="wpsOutputID" type="xs:string" minOccurs="0"/>
|
||||
<xs:element name="wpsDataSchema" type="xs:string" minOccurs="0"/>
|
||||
<xs:element name="wpsMimeType" type="xs:string" minOccurs="0"/>
|
||||
<xs:element name="wpsLiteralDataTye" type="xs:string" minOccurs="0"/>
|
||||
<xs:element name="wpsDefaultCRS" type="xs:string" minOccurs="0"/>
|
||||
</xs:sequence>
|
||||
</xs:complexType>
|
||||
<!-- ========================================================================== -->
|
||||
<xs:simpleType name="legacyIntIDType">
|
||||
<xs:restriction base="xs:int"/>
|
||||
</xs:simpleType>
|
||||
<!-- ========================================================================== -->
|
||||
<xs:simpleType name="legacyStrindIDType">
|
||||
<xs:restriction base="xs:string"/>
|
||||
</xs:simpleType>
|
||||
</xs:schema>
|
||||
@ -1,57 +0,0 @@
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<?xml-stylesheet type="text/xsl" href="D:/localWPSFiles/legacyDescriptions/dummyPython.xslt" ?>
|
||||
<wps:ProcessDescriptions xmlns:wps="http://www.opengis.net/wps/1.0.0" xmlns:ows="http://www.opengis.net/ows/1.1" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.opengis.net/wps/1.0.0
|
||||
http://schemas.opengis.net/wps/1.0.0/wpsDescribeProcess_response.xsd" xml:lang="en-US" service="WPS" version="1.0.0">
|
||||
<ProcessDescription wps:processVersion="2" storeSupported="true" statusSupported="false">
|
||||
<ows:Identifier>org.n52.wps.ags.algorithm.DummyPython</ows:Identifier>
|
||||
<ows:Title>dummy algorithm</ows:Title>
|
||||
<ows:Abstract>Uses ArcGIS Server Backend</ows:Abstract>
|
||||
<ows:Metadata xlink:title="dummyPython" ></ows:Metadata>
|
||||
<DataInputs>
|
||||
<Input minOccurs="1" maxOccurs="1">
|
||||
<ows:Identifier>INPUT_FILE</ows:Identifier>
|
||||
<ows:Title>input file</ows:Title>
|
||||
<ows:Abstract>some file</ows:Abstract>
|
||||
<ComplexData>
|
||||
<Default>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Default>
|
||||
<Supported>
|
||||
<Format>
|
||||
<MimeType>application/GeoTIFF</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Supported>
|
||||
</ComplexData>
|
||||
</Input>
|
||||
</DataInputs>
|
||||
<ProcessOutputs>
|
||||
<Output>
|
||||
<ows:Identifier>OUTPUT_FILE</ows:Identifier>
|
||||
<ows:Title>output file</ows:Title>
|
||||
<ows:Abstract>another file</ows:Abstract>
|
||||
<ComplexOutput>
|
||||
<Default>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Default>
|
||||
<Supported>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Supported>
|
||||
</ComplexOutput>
|
||||
</Output>
|
||||
</ProcessOutputs>
|
||||
</ProcessDescription>
|
||||
</wps:ProcessDescriptions>
|
||||
@ -1,74 +0,0 @@
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<!--
|
||||
Example mapping file for Python Scripts
|
||||
|
||||
Author: Matthias Mueller, TU Dresden
|
||||
-->
|
||||
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform" xmlns:ows="http://www.opengis.net/ows/1.1" xmlns:wps="http://www.opengis.net/wps/1.0.0" xmlns:xs="http://www.w3.org/2001/XMLSchema" exclude-result-prefixes="ows wps xs">
|
||||
<xsl:output method="xml" encoding="UTF-8" indent="yes"/>
|
||||
<xsl:template match="/">
|
||||
<xsl:variable name="docRoot" select="."/>
|
||||
<GPAlgorithmDescription>
|
||||
<xsl:attribute name="xsi:tns" namespace="http://www.w3.org/2001/XMLSchema-instance">
|
||||
<xsl:value-of select="'http://52north.org/svn/geoprocessing/main/WPS/trunk/WPS/52n-wps-webapp/src/main/webapp/examples/LegacyAlgorithmSchema.xsd'"/>
|
||||
</xsl:attribute>
|
||||
<algorithmWorkspaceLocation>http://gp-algorithms.tu-dresden.de/DummyPython</algorithmWorkspaceLocation>
|
||||
<algorithmContainerLocation>http://gp-algorithms.tu-dresden.de/DummyPython/dummy.py</algorithmContainerLocation>
|
||||
<algorithmLocation>http://gp-algorithms.tu-dresden.de/DummyPython/dummy.py?</algorithmLocation>
|
||||
<algorithmContainerURN>urn:n52:python:2.5</algorithmContainerURN>
|
||||
<processingSystemURN>urn:n52:esri:arcgis:9.3</processingSystemURN>
|
||||
<algorithmParameters sequential="true">
|
||||
|
||||
<!-- Inputs -->
|
||||
<xsl:for-each select="$docRoot/wps:ProcessDescriptions/ProcessDescription/DataInputs/Input">
|
||||
<xsl:variable name="var2_Input" select="."/>
|
||||
<xsl:variable name="inputItem" select="."/>
|
||||
<xsl:if test="string($inputItem/ows:Identifier) = 'INPUT_FILE'">
|
||||
<parameter>
|
||||
<prefixString/>
|
||||
<suffixString/>
|
||||
<separatorString/>
|
||||
<legacyIntID>0</legacyIntID>
|
||||
<wpsInputID><xsl:value-of select="ows:Identifier"/></wpsInputID>
|
||||
<wpsOutputID/>
|
||||
<xsl:call-template name="tInputParam"/>
|
||||
</parameter>
|
||||
</xsl:if>
|
||||
</xsl:for-each>
|
||||
|
||||
<!-- Outputs -->
|
||||
<xsl:for-each select="$docRoot/wps:ProcessDescriptions/ProcessDescription/ProcessOutputs/Output">
|
||||
<xsl:variable name="var3_Output" select="."/>
|
||||
<xsl:variable name="outputItem" select="."/>
|
||||
<xsl:if test="string($outputItem/ows:Identifier) = 'OUTPUT_FILE'">
|
||||
<parameter>
|
||||
<prefixString/>
|
||||
<suffixString/>
|
||||
<separatorString/>
|
||||
<legacyIntID>1</legacyIntID>
|
||||
<wpsInputID/>
|
||||
<wpsOutputID><xsl:value-of select="ows:Identifier"/></wpsOutputID>
|
||||
<xsl:call-template name="tOutputParam"/>
|
||||
</parameter>
|
||||
</xsl:if>
|
||||
</xsl:for-each>
|
||||
|
||||
</algorithmParameters>
|
||||
</GPAlgorithmDescription>
|
||||
</xsl:template>
|
||||
|
||||
<xsl:template name="tInputParam">
|
||||
<wpsDataSchema><xsl:value-of select="ComplexData/Default/Format/Schema"/></wpsDataSchema>
|
||||
<wpsMimeType><xsl:value-of select="ComplexData/Default/Format/MimeType"/></wpsMimeType>
|
||||
<wpsLiteralDataTye><xsl:value-of select="LiteralData/ows:DataType"/></wpsLiteralDataTye>
|
||||
<wpsDefaultCRS><xsl:value-of select="BoundingBoxData/Default/CRS"/></wpsDefaultCRS>
|
||||
</xsl:template>
|
||||
|
||||
<xsl:template name="tOutputParam">
|
||||
<wpsDataSchema><xsl:value-of select="ComplexOutput/Default/Format/Schema"/></wpsDataSchema>
|
||||
<wpsMimeType><xsl:value-of select="ComplexOutput/Default/Format/MimeType"/></wpsMimeType>
|
||||
<wpsLiteralDataTye><xsl:value-of select="LiteralOutput/ows:DataType"/></wpsLiteralDataTye>
|
||||
<wpsDefaultCRS><xsl:value-of select="BoundingBoxOutput/Default/CRS"/></wpsDefaultCRS>
|
||||
</xsl:template>
|
||||
|
||||
</xsl:stylesheet>
|
||||
@ -1,85 +0,0 @@
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" elementFormDefault="qualified" attributeFormDefault="qualified">
|
||||
<xs:element name="GPAlgorithmDescription">
|
||||
<xs:annotation>
|
||||
<xs:documentation>Comment describing your root element</xs:documentation>
|
||||
</xs:annotation>
|
||||
<xs:complexType>
|
||||
<xs:sequence>
|
||||
<xs:element name="algorithmWorkspaceLocation" type="xs:anyURI">
|
||||
<xs:annotation>
|
||||
<xs:documentation>URL pointing to the workspace root</xs:documentation>
|
||||
</xs:annotation>
|
||||
</xs:element>
|
||||
<xs:element name="algorithmContainerLocation" type="xs:anyURI">
|
||||
<xs:annotation>
|
||||
<xs:documentation>URL pointing to the algorithm; relative to the workspace root. If appropriate, this location can point to some location within the container</xs:documentation>
|
||||
</xs:annotation>
|
||||
</xs:element>
|
||||
<xs:element name="algorithmLocation" type="xs:anyURI" minOccurs="0">
|
||||
<xs:annotation>
|
||||
<xs:documentation>Optional URL pointing to a location within the algorithm container. This is e.g. useful to acces tools inside ArcGIS Toolboxes</xs:documentation>
|
||||
</xs:annotation>
|
||||
</xs:element>
|
||||
<xs:element name="algorithmContainerURN" type="xs:anyURI">
|
||||
<xs:annotation>
|
||||
<xs:documentation>URN referencing the specific container, e.g. urn:n52:wps:algorithmcontainer:arctoolbox:9.3</xs:documentation>
|
||||
</xs:annotation>
|
||||
</xs:element>
|
||||
<xs:element name="processingSystemURN" type="xs:anyURI" maxOccurs="unbounded">
|
||||
<xs:annotation>
|
||||
<xs:documentation>URN referencing a required processing backend, e.g. urn:n52:wps:gpsystem:arcgis:9.3</xs:documentation>
|
||||
</xs:annotation>
|
||||
</xs:element>
|
||||
<xs:element name="algorithmParameters">
|
||||
<xs:annotation>
|
||||
<xs:documentation>A collection of the algorithm parameters</xs:documentation>
|
||||
</xs:annotation>
|
||||
<xs:complexType>
|
||||
<xs:sequence>
|
||||
<xs:element name="parameter" type="AlgorithmParameterType" maxOccurs="unbounded">
|
||||
<xs:annotation>
|
||||
<xs:documentation>The tool's parameters</xs:documentation>
|
||||
</xs:annotation>
|
||||
</xs:element>
|
||||
</xs:sequence>
|
||||
<xs:attribute name="sequential" type="xs:boolean">
|
||||
<xs:annotation>
|
||||
<xs:documentation>If true, this tool's parameters are indexed through their position as integers. Otherwise, the mapping from the ows:Identifier to the respective LegacyID is done via name strings.</xs:documentation>
|
||||
</xs:annotation>
|
||||
</xs:attribute>
|
||||
</xs:complexType>
|
||||
</xs:element>
|
||||
</xs:sequence>
|
||||
</xs:complexType>
|
||||
</xs:element>
|
||||
<!-- ========================================================================== -->
|
||||
<xs:complexType name="AlgorithmParameterType">
|
||||
<xs:sequence>
|
||||
<xs:element name="prefixString" type="xs:string" minOccurs="0"/>
|
||||
<xs:element name="suffixString" type="xs:string" minOccurs="0"/>
|
||||
<xs:element name="separatorString" type="xs:string" minOccurs="0"/>
|
||||
<xs:choice>
|
||||
<xs:annotation>
|
||||
<xs:documentation>The Legacy ID by which the parameters are defined in the Legacy environment. Use legacyIntID for sequential parameters, legacyStrindID for parameters name strings</xs:documentation>
|
||||
</xs:annotation>
|
||||
<xs:element name="legacyIntID" type="legacyIntIDType"/>
|
||||
<xs:element name="legacyStrindID" type="legacyStrindIDType"/>
|
||||
</xs:choice>
|
||||
<xs:element name="wpsInputID" type="xs:string" minOccurs="0"/>
|
||||
<xs:element name="wpsOutputID" type="xs:string" minOccurs="0"/>
|
||||
<xs:element name="wpsDataSchema" type="xs:string" minOccurs="0"/>
|
||||
<xs:element name="wpsMimeType" type="xs:string" minOccurs="0"/>
|
||||
<xs:element name="wpsLiteralDataTye" type="xs:string" minOccurs="0"/>
|
||||
<xs:element name="wpsDefaultCRS" type="xs:string" minOccurs="0"/>
|
||||
</xs:sequence>
|
||||
</xs:complexType>
|
||||
<!-- ========================================================================== -->
|
||||
<xs:simpleType name="legacyIntIDType">
|
||||
<xs:restriction base="xs:int"/>
|
||||
</xs:simpleType>
|
||||
<!-- ========================================================================== -->
|
||||
<xs:simpleType name="legacyStrindIDType">
|
||||
<xs:restriction base="xs:string"/>
|
||||
</xs:simpleType>
|
||||
</xs:schema>
|
||||
@ -1,73 +0,0 @@
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<?xml-stylesheet type="text/xsl" href="D:/localWPSFiles/legacyDescriptions/perimeter.xslt" ?>
|
||||
<wps:ProcessDescriptions xmlns:wps="http://www.opengis.net/wps/1.0.0" xmlns:ows="http://www.opengis.net/ows/1.1" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.opengis.net/wps/1.0.0
|
||||
http://schemas.opengis.net/wps/1.0.0/wpsDescribeProcess_response.xsd" xml:lang="en-US" service="WPS" version="1.0.0">
|
||||
<ProcessDescription wps:processVersion="2" storeSupported="true" statusSupported="false">
|
||||
<ows:Identifier>de.soknos.wps.FloodPerimeter</ows:Identifier>
|
||||
<ows:Title>Raster to vector Conversion</ows:Title>
|
||||
<ows:Abstract>Convert HWSIM raster data to vector data</ows:Abstract>
|
||||
<ows:Metadata xlink:title="spatial" ></ows:Metadata>
|
||||
<ows:Metadata xlink:title="raster" />
|
||||
<DataInputs>
|
||||
<Input minOccurs="1" maxOccurs="1">
|
||||
<ows:Identifier>INTEGER_RASTER</ows:Identifier>
|
||||
<ows:Title>input raster</ows:Title>
|
||||
<ows:Abstract>cell based water levels from INTEGER_RASTER</ows:Abstract>
|
||||
<ComplexData>
|
||||
<Default>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Default>
|
||||
<Supported>
|
||||
<Format>
|
||||
<MimeType>application/GeoTIFF</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Supported>
|
||||
</ComplexData>
|
||||
</Input>
|
||||
<Input minOccurs="1" maxOccurs="1">
|
||||
<ows:Identifier>SIMPLIFICATION</ows:Identifier>
|
||||
<ows:Title>simplification indicator</ows:Title>
|
||||
<ows:Abstract>composite indicator, 5 is the suggested value</ows:Abstract>
|
||||
<LiteralData>
|
||||
<ows:DataType ows:reference="xs:int"></ows:DataType>
|
||||
<ows:AllowedValues>
|
||||
<ows:Value></ows:Value>
|
||||
</ows:AllowedValues>
|
||||
</LiteralData>
|
||||
</Input>
|
||||
</DataInputs>
|
||||
<ProcessOutputs>
|
||||
<Output>
|
||||
<ows:Identifier>PERIMETER</ows:Identifier>
|
||||
<ows:Title>Rough border estimates around the integer zones</ows:Title>
|
||||
<ows:Abstract>indicates the main flooded ares</ows:Abstract>
|
||||
<ComplexOutput>
|
||||
<Default>
|
||||
<Format>
|
||||
<MimeType>application/x-zipped-shp</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Default>
|
||||
<Supported>
|
||||
<Format>
|
||||
<MimeType>application/x-zipped-shp</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
<Format>
|
||||
<MimeType>text/XML</MimeType>
|
||||
<Schema>http://schemas.opengis.net/gml/2.1.2/feature.xsd</Schema>
|
||||
</Format>
|
||||
</Supported>
|
||||
</ComplexOutput>
|
||||
</Output>
|
||||
</ProcessOutputs>
|
||||
</ProcessDescription>
|
||||
</wps:ProcessDescriptions>
|
||||
@ -1,88 +0,0 @@
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<!--
|
||||
Mapping file for perimeter.xml
|
||||
|
||||
Author: Matthias Mueller, TU Dresden
|
||||
-->
|
||||
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform" xmlns:ows="http://www.opengis.net/ows/1.1" xmlns:wps="http://www.opengis.net/wps/1.0.0" xmlns:xs="http://www.w3.org/2001/XMLSchema" exclude-result-prefixes="ows wps xs">
|
||||
<xsl:output method="xml" encoding="UTF-8" indent="yes"/>
|
||||
<xsl:template match="/">
|
||||
<xsl:variable name="docRoot" select="."/>
|
||||
<GPAlgorithmDescription>
|
||||
<xsl:attribute name="xsi:tns" namespace="http://www.w3.org/2001/XMLSchema-instance">
|
||||
<xsl:value-of select="'http://52north.org/svn/geoprocessing/main/WPS/trunk/WPS/52n-wps-webapp/src/main/webapp/examples/LegacyAlgorithmSchema.xsd'"/>
|
||||
</xsl:attribute>
|
||||
|
||||
<!-- General parameters -->
|
||||
<algorithmWorkspaceLocation>http://gp-algorithms.tu-dresden.de/de.tu-dresden.wps.perimeter</algorithmWorkspaceLocation>
|
||||
<algorithmContainerLocation>http://gp-algorithms.tu-dresden.de/de.tu-dresden.wps.perimeter/toolbox.tbx</algorithmContainerLocation>
|
||||
<algorithmLocation>http://gp-algorithms.tu-dresden.de/de.tu-dresden.wps.perimeter/toolbox.tbx?perimeter</algorithmLocation>
|
||||
<algorithmContainerURN>urn:n52:esri:arctoolbox:9.3</algorithmContainerURN>
|
||||
<processingSystemURN>urn:n52:esri:arcgis:9.3</processingSystemURN>
|
||||
|
||||
<algorithmParameters sequential="true">
|
||||
|
||||
<!-- Inputs -->
|
||||
<xsl:for-each select="$docRoot/wps:ProcessDescriptions/ProcessDescription/DataInputs/Input">
|
||||
<xsl:variable name="var2_Input" select="."/>
|
||||
<xsl:variable name="inputItem" select="."/>
|
||||
<xsl:if test="string($inputItem/ows:Identifier) = 'INTEGER_RASTER'">
|
||||
<parameter>
|
||||
<prefixString/>
|
||||
<suffixString/>
|
||||
<separatorString/>
|
||||
<legacyIntID>0</legacyIntID>
|
||||
<wpsInputID><xsl:value-of select="ows:Identifier"/></wpsInputID>
|
||||
<wpsOutputID/>
|
||||
<xsl:call-template name="tInputParam"/>
|
||||
</parameter>
|
||||
</xsl:if>
|
||||
<xsl:if test="string($inputItem/ows:Identifier) = 'SIMPLIFICATION'">
|
||||
<parameter>
|
||||
<prefixString/>
|
||||
<suffixString/>
|
||||
<separatorString/>
|
||||
<legacyIntID>1</legacyIntID>
|
||||
<wpsInputID><xsl:value-of select="ows:Identifier"/></wpsInputID>
|
||||
<wpsOutputID/>
|
||||
<xsl:call-template name="tInputParam"/>
|
||||
</parameter>
|
||||
</xsl:if>
|
||||
</xsl:for-each>
|
||||
|
||||
<!-- Outputs -->
|
||||
<xsl:for-each select="$docRoot/wps:ProcessDescriptions/ProcessDescription/ProcessOutputs/Output">
|
||||
<xsl:variable name="var3_Output" select="."/>
|
||||
<xsl:variable name="outputItem" select="."/>
|
||||
<xsl:if test="string($outputItem/ows:Identifier) = 'PERIMETER'">
|
||||
<parameter>
|
||||
<prefixString/>
|
||||
<suffixString/>
|
||||
<separatorString/>
|
||||
<legacyIntID>2</legacyIntID>
|
||||
<wpsInputID/>
|
||||
<wpsOutputID><xsl:value-of select="ows:Identifier"/></wpsOutputID>
|
||||
<xsl:call-template name="tOutputParam"/>
|
||||
</parameter>
|
||||
</xsl:if>
|
||||
</xsl:for-each>
|
||||
|
||||
</algorithmParameters>
|
||||
</GPAlgorithmDescription>
|
||||
</xsl:template>
|
||||
|
||||
<xsl:template name="tInputParam">
|
||||
<wpsDataSchema><xsl:value-of select="ComplexData/Default/Format/Schema"/></wpsDataSchema>
|
||||
<wpsMimeType><xsl:value-of select="ComplexData/Default/Format/MimeType"/></wpsMimeType>
|
||||
<wpsLiteralDataTye><xsl:value-of select="LiteralData/ows:DataType"/></wpsLiteralDataTye>
|
||||
<wpsDefaultCRS><xsl:value-of select="BoundingBoxData/Default/CRS"/></wpsDefaultCRS>
|
||||
</xsl:template>
|
||||
|
||||
<xsl:template name="tOutputParam">
|
||||
<wpsDataSchema><xsl:value-of select="ComplexOutput/Default/Format/Schema"/></wpsDataSchema>
|
||||
<wpsMimeType><xsl:value-of select="ComplexOutput/Default/Format/MimeType"/></wpsMimeType>
|
||||
<wpsLiteralDataTye><xsl:value-of select="LiteralOutput/ows:DataType"/></wpsLiteralDataTye>
|
||||
<wpsDefaultCRS><xsl:value-of select="BoundingBoxOutput/Default/CRS"/></wpsDefaultCRS>
|
||||
</xsl:template>
|
||||
|
||||
</xsl:stylesheet>
|
||||
Binary file not shown.
@ -1,9 +0,0 @@
|
||||
# dummy algorithm, just copies an input file
|
||||
|
||||
import shutil, sys
|
||||
|
||||
inFile = sys.argv[1]
|
||||
outFile = sys.argv[2]
|
||||
|
||||
shutil.copy (inFile, outFile)
|
||||
|
||||
@ -1,85 +0,0 @@
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<wps:ProcessDescriptions xmlns:wps="http://www.opengis.net/wps/1.0.0" xmlns:ows="http://www.opengis.net/ows/1.1" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.opengis.net/wps/1.0.0
|
||||
http://schemas.opengis.net/wps/1.0.0/wpsDescribeProcess_response.xsd" xml:lang="en-US" service="WPS" version="1.0.0">
|
||||
<ProcessDescription wps:processVersion="2" statusSupported="true" storeSupported="true">
|
||||
<ows:Identifier>org.n52.wps.ags.analysis.extract.clip</ows:Identifier><!-- ParameterCount=4 -->
|
||||
<ows:Title>Clip_analysis</ows:Title>
|
||||
<ows:Abstract>This extracts input features that overlay the clip features. Uses ArcObjects library - Analysis</ows:Abstract>
|
||||
<DataInputs>
|
||||
<Input minOccurs="1" maxOccurs="1">
|
||||
<ows:Identifier>in_features</ows:Identifier><!-- 0 -->
|
||||
<ows:Title>in features</ows:Title>
|
||||
<ows:Abstract>The features to be clipped.</ows:Abstract>
|
||||
<ComplexData>
|
||||
<Default>
|
||||
<Format>
|
||||
<MimeType>application/x-zipped-shp</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Default>
|
||||
<Supported>
|
||||
<Format>
|
||||
<MimeType>application/x-zipped-shp</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Supported>
|
||||
</ComplexData>
|
||||
</Input>
|
||||
<Input minOccurs="1" maxOccurs="1">
|
||||
<ows:Identifier>clip_feature</ows:Identifier><!-- 1 -->
|
||||
<ows:Title>clip feature</ows:Title>
|
||||
<ows:Abstract>The features used to clip the input features.</ows:Abstract>
|
||||
<ComplexData>
|
||||
<Default>
|
||||
<Format>
|
||||
<MimeType>application/x-zipped-shp</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Default>
|
||||
<Supported>
|
||||
<Format>
|
||||
<MimeType>application/x-zipped-shp</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Supported>
|
||||
</ComplexData>
|
||||
</Input>
|
||||
<Input minOccurs="0" maxOccurs="1">
|
||||
<ows:Identifier>cluster_tolerance</ows:Identifier><!-- 3 -->
|
||||
<ows:Title>cluster tolerance</ows:Title>
|
||||
<ows:Abstract>The minimum distance separating all feature coordinates (nodes and vertices) as well as the distance a coordinate can move in X or Y (or both). You can set the value to be higher for data that has less coordinate accuracy and lower for datasets with extremely high accuracy.</ows:Abstract>
|
||||
<LiteralData>
|
||||
<ows:DataType ows:reference="xs:string"></ows:DataType>
|
||||
<ows:AnyValue/>
|
||||
</LiteralData>
|
||||
</Input>
|
||||
</DataInputs>
|
||||
<ProcessOutputs>
|
||||
<Output>
|
||||
<ows:Identifier>out_feature_class</ows:Identifier><!-- 2 -->
|
||||
<ows:Title>out feature class</ows:Title>
|
||||
<ows:Abstract>The feature class to be created.</ows:Abstract>
|
||||
<ComplexOutput>
|
||||
<Default>
|
||||
<Format>
|
||||
<MimeType>application/x-zipped-shp</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Default>
|
||||
<Supported>
|
||||
<Format>
|
||||
<MimeType>application/x-zipped-shp</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
<Format>
|
||||
<MimeType>text/XML</MimeType>
|
||||
<Schema>http://schemas.opengis.net/gml/2.1.2/feature.xsd</Schema>
|
||||
</Format>
|
||||
</Supported>
|
||||
</ComplexOutput>
|
||||
</Output>
|
||||
</ProcessOutputs>
|
||||
</ProcessDescription>
|
||||
</wps:ProcessDescriptions>
|
||||
|
||||
|
||||
@ -1,70 +0,0 @@
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<wps:ProcessDescriptions xmlns:wps="http://www.opengis.net/wps/1.0.0" xmlns:ows="http://www.opengis.net/ows/1.1" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.opengis.net/wps/1.0.0
|
||||
http://schemas.opengis.net/wps/1.0.0/wpsDescribeProcess_response.xsd" xml:lang="en-US" service="WPS" version="1.0.0">
|
||||
<ProcessDescription wps:processVersion="2" statusSupported="true" storeSupported="true">
|
||||
<ows:Identifier>org.n52.wps.ags.analysis.extract.select</ows:Identifier><!-- ParameterCount=3 -->
|
||||
<ows:Title>Select_analysis</ows:Title>
|
||||
<ows:Abstract>Extracts features from an input feature class or input feature layer and stores them in a new output feature class. The output feature class may be created with a subset of features based on a Structured Query Language (SQL) expression. Uses ArcObjects library - Analysis</ows:Abstract>
|
||||
<DataInputs>
|
||||
<Input minOccurs="1" maxOccurs="1">
|
||||
<ows:Identifier>in_features</ows:Identifier><!-- 0 -->
|
||||
<ows:Title>in features</ows:Title>
|
||||
<ows:Abstract>The input feature class or layer from which features are selected.</ows:Abstract>
|
||||
<ComplexData>
|
||||
<Default>
|
||||
<Format>
|
||||
<MimeType>application/x-zipped-shp</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Default>
|
||||
<Supported>
|
||||
<Format>
|
||||
<MimeType>application/x-zipped-shp</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Supported>
|
||||
</ComplexData>
|
||||
</Input>
|
||||
<Input minOccurs="0" maxOccurs="1">
|
||||
<ows:Identifier>where_clause</ows:Identifier><!-- 2 -->
|
||||
<ows:Title>where clause</ows:Title>
|
||||
<ows:Abstract>An expression used to select a subset of features.
|
||||
In the command line, the {where_clause} should be enclosed in parentheses, as it will contain spaces which are delimiters between parameters. Another option is to right-click on the command line and select Insert Variable (or use the F8 shortcut).
|
||||
The syntax for the expression differs slightly depending on the data source. For example, if you're querying file or ArcSDE geodatabases, shapefiles, or coverages, enclose field names in double quotes:
|
||||
"MY_FIELD" If you're querying personal geodatabases, enclose fields in square brackets:
|
||||
[MY_FIELD] For more information on SQL syntax and how it differs between data sources, see SQL Reference.</ows:Abstract>
|
||||
<LiteralData>
|
||||
<ows:DataType ows:reference="xs:string"></ows:DataType>
|
||||
<ows:AnyValue/>
|
||||
</LiteralData>
|
||||
</Input>
|
||||
</DataInputs>
|
||||
<ProcessOutputs>
|
||||
<Output>
|
||||
<ows:Identifier>out_feature_class</ows:Identifier><!-- 1 -->
|
||||
<ows:Title>out feature class</ows:Title>
|
||||
<ows:Abstract>The output feature class to be created. This feature class will contain all the features from the input if no expression is specified.</ows:Abstract>
|
||||
<ComplexOutput>
|
||||
<Default>
|
||||
<Format>
|
||||
<MimeType>application/x-zipped-shp</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Default>
|
||||
<Supported>
|
||||
<Format>
|
||||
<MimeType>application/x-zipped-shp</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
<Format>
|
||||
<MimeType>text/XML</MimeType>
|
||||
<Schema>http://schemas.opengis.net/gml/2.1.2/feature.xsd</Schema>
|
||||
</Format>
|
||||
</Supported>
|
||||
</ComplexOutput>
|
||||
</Output>
|
||||
</ProcessOutputs>
|
||||
</ProcessDescription>
|
||||
</wps:ProcessDescriptions>
|
||||
|
||||
|
||||
@ -1,65 +0,0 @@
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<wps:ProcessDescriptions xmlns:wps="http://www.opengis.net/wps/1.0.0" xmlns:ows="http://www.opengis.net/ows/1.1" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.opengis.net/wps/1.0.0
|
||||
http://schemas.opengis.net/wps/1.0.0/wpsDescribeProcess_response.xsd" xml:lang="en-US" service="WPS" version="1.0.0">
|
||||
<ProcessDescription wps:processVersion="2" statusSupported="true" storeSupported="true">
|
||||
<ows:Identifier>org.n52.wps.ags.analysis.extract.split</ows:Identifier><!-- ParameterCount=3 -->
|
||||
<ows:Title>TableSelect_analysis</ows:Title>
|
||||
<ows:Abstract>This extracts selected table records or features from an input table or table view and stores them in a new output table. Uses ArcObjects library - Analysis</ows:Abstract>
|
||||
<DataInputs>
|
||||
<Input minOccurs="1" maxOccurs="1">
|
||||
<ows:Identifier>in_table</ows:Identifier><!-- 0 -->
|
||||
<ows:Title>in table</ows:Title>
|
||||
<ows:Abstract>The input table can be an INFO table, a dBASE table, a geodatabase table, a feature class, or a table view.</ows:Abstract>
|
||||
<ComplexData>
|
||||
<Default>
|
||||
<Format>
|
||||
<MimeType>application/dbf</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Default>
|
||||
<Supported>
|
||||
<Format>
|
||||
<MimeType>application/dbf</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Supported>
|
||||
</ComplexData>
|
||||
</Input>
|
||||
<Input minOccurs="0" maxOccurs="1">
|
||||
<ows:Identifier>where_clause</ows:Identifier><!-- 2 -->
|
||||
<ows:Title>where clause</ows:Title>
|
||||
<ows:Abstract>A SQL expression used to select a subset of records.
|
||||
The syntax for the expression differs slightly depending on the data source. For example, if you're querying file or ArcSDE geodatabases or dBASE or INFO tables, enclose field names in double quotes:
|
||||
"MY_FIELD" If you're querying personal geodatabases, enclose fields in square brackets:
|
||||
[MY_FIELD] For more information on SQL syntax and how it differs between data sources, see SQL Reference.</ows:Abstract>
|
||||
<LiteralData>
|
||||
<ows:DataType ows:reference="xs:string"></ows:DataType>
|
||||
<ows:AnyValue/>
|
||||
</LiteralData>
|
||||
</Input>
|
||||
</DataInputs>
|
||||
<ProcessOutputs>
|
||||
<Output>
|
||||
<ows:Identifier>out_table</ows:Identifier><!-- 1 -->
|
||||
<ows:Title>out table</ows:Title>
|
||||
<ows:Abstract>The output table to be created. The output table can be a geodatabase table, a dBASE table, or an INFO table. If the output location is in a folder and no extension is specified, the output will be an INFO table.</ows:Abstract>
|
||||
<ComplexOutput>
|
||||
<Default>
|
||||
<Format>
|
||||
<MimeType>application/dbf</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Default>
|
||||
<Supported>
|
||||
<Format>
|
||||
<MimeType>application/dbf</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Supported>
|
||||
</ComplexOutput>
|
||||
</Output>
|
||||
</ProcessOutputs>
|
||||
</ProcessDescription>
|
||||
</wps:ProcessDescriptions>
|
||||
|
||||
|
||||
@ -1,85 +0,0 @@
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<wps:ProcessDescriptions xmlns:wps="http://www.opengis.net/wps/1.0.0" xmlns:ows="http://www.opengis.net/ows/1.1" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.opengis.net/wps/1.0.0
|
||||
http://schemas.opengis.net/wps/1.0.0/wpsDescribeProcess_response.xsd" xml:lang="en-US" service="WPS" version="1.0.0">
|
||||
<ProcessDescription wps:processVersion="2" statusSupported="true" storeSupported="true">
|
||||
<ows:Identifier>org.n52.wps.ags.analysis.overlay.erase</ows:Identifier><!-- ParameterCount=4 -->
|
||||
<ows:Title>Erase_analysis</ows:Title>
|
||||
<ows:Abstract>Creates a feature class by overlaying the Input Features with the polygons of the Erase Features. Only those portions of the Input Features falling outside the Erase Features outside boundaries are copied to the Output Feature Class. Uses ArcObjects library - Analysis</ows:Abstract>
|
||||
<DataInputs>
|
||||
<Input minOccurs="1" maxOccurs="1">
|
||||
<ows:Identifier>in_features</ows:Identifier><!-- 0 -->
|
||||
<ows:Title>in features</ows:Title>
|
||||
<ows:Abstract>The input feature class or layer.</ows:Abstract>
|
||||
<ComplexData>
|
||||
<Default>
|
||||
<Format>
|
||||
<MimeType>application/x-zipped-shp</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Default>
|
||||
<Supported>
|
||||
<Format>
|
||||
<MimeType>application/x-zipped-shp</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Supported>
|
||||
</ComplexData>
|
||||
</Input>
|
||||
<Input minOccurs="1" maxOccurs="1">
|
||||
<ows:Identifier>erase_features</ows:Identifier><!-- 1 -->
|
||||
<ows:Title>erase features</ows:Title>
|
||||
<ows:Abstract>The features whose outer polygon defines the erasing area.</ows:Abstract>
|
||||
<ComplexData>
|
||||
<Default>
|
||||
<Format>
|
||||
<MimeType>application/x-zipped-shp</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Default>
|
||||
<Supported>
|
||||
<Format>
|
||||
<MimeType>application/x-zipped-shp</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Supported>
|
||||
</ComplexData>
|
||||
</Input>
|
||||
<Input minOccurs="0" maxOccurs="1">
|
||||
<ows:Identifier>cluster_tolerance</ows:Identifier><!-- 3 -->
|
||||
<ows:Title>cluster tolerance</ows:Title>
|
||||
<ows:Abstract>The minimum distance separating all feature coordinates (nodes and vertices) as well as the distance a coordinate can move in X or Y (or both). You can set the value to be higher for data that has less coordinate accuracy and lower for datasets with extremely high accuracy.</ows:Abstract>
|
||||
<LiteralData>
|
||||
<ows:DataType ows:reference="xs:string"></ows:DataType>
|
||||
<ows:AnyValue/>
|
||||
</LiteralData>
|
||||
</Input>
|
||||
</DataInputs>
|
||||
<ProcessOutputs>
|
||||
<Output>
|
||||
<ows:Identifier>out_feature_class</ows:Identifier><!-- 2 -->
|
||||
<ows:Title>out feature class</ows:Title>
|
||||
<ows:Abstract>The feature class that will contain only those Input Features that lie outside the Erase Features area.</ows:Abstract>
|
||||
<ComplexOutput>
|
||||
<Default>
|
||||
<Format>
|
||||
<MimeType>application/x-zipped-shp</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Default>
|
||||
<Supported>
|
||||
<Format>
|
||||
<MimeType>application/x-zipped-shp</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
<Format>
|
||||
<MimeType>text/XML</MimeType>
|
||||
<Schema>http://schemas.opengis.net/gml/2.1.2/feature.xsd</Schema>
|
||||
</Format>
|
||||
</Supported>
|
||||
</ComplexOutput>
|
||||
</Output>
|
||||
</ProcessOutputs>
|
||||
</ProcessDescription>
|
||||
</wps:ProcessDescriptions>
|
||||
|
||||
|
||||
@ -1,110 +0,0 @@
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<wps:ProcessDescriptions xmlns:wps="http://www.opengis.net/wps/1.0.0" xmlns:ows="http://www.opengis.net/ows/1.1" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.opengis.net/wps/1.0.0
|
||||
http://schemas.opengis.net/wps/1.0.0/wpsDescribeProcess_response.xsd" xml:lang="en-US" service="WPS" version="1.0.0">
|
||||
<ProcessDescription wps:processVersion="2" statusSupported="true" storeSupported="true">
|
||||
<ows:Identifier>org.n52.wps.ags.analysis.overlay.identity</ows:Identifier><!-- ParameterCount=6 -->
|
||||
<ows:Title>Identity_analysis</ows:Title>
|
||||
<ows:Abstract>Computes a geometric intersection of the Input Features and Identity Features. The Input Features or portions thereof that overlap Identity Features will get the attributes of those Identity Features. Uses ArcObjects library - Analysis</ows:Abstract>
|
||||
<DataInputs>
|
||||
<Input minOccurs="1" maxOccurs="1">
|
||||
<ows:Identifier>in_features</ows:Identifier><!-- 0 -->
|
||||
<ows:Title>in features</ows:Title>
|
||||
<ows:Abstract>The input feature class or layer.</ows:Abstract>
|
||||
<ComplexData>
|
||||
<Default>
|
||||
<Format>
|
||||
<MimeType>application/x-zipped-shp</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Default>
|
||||
<Supported>
|
||||
<Format>
|
||||
<MimeType>application/x-zipped-shp</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Supported>
|
||||
</ComplexData>
|
||||
</Input>
|
||||
<Input minOccurs="1" maxOccurs="1">
|
||||
<ows:Identifier>identify_features</ows:Identifier><!-- 1 -->
|
||||
<ows:Title>identify features</ows:Title>
|
||||
<ows:Abstract>The identity feature class or layer. Must be polygons.</ows:Abstract>
|
||||
<ComplexData>
|
||||
<Default>
|
||||
<Format>
|
||||
<MimeType>application/x-zipped-shp</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Default>
|
||||
<Supported>
|
||||
<Format>
|
||||
<MimeType>application/x-zipped-shp</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Supported>
|
||||
</ComplexData>
|
||||
</Input>
|
||||
<Input minOccurs="0" maxOccurs="1">
|
||||
<ows:Identifier>join_attributes</ows:Identifier><!-- 3 -->
|
||||
<ows:Title>join attributes</ows:Title>
|
||||
<ows:Abstract>Determines what attributes will be transferred to the Output Feature Class. ALL — All the attributes (including FIDs) from the Input Features as well as the Identity Features will be transferred to the Output Feature Class. This is the default. NO_FID — All the attributes except the FID from the Input Features and Identity Features will be transferred to the Output Feature Class. ONLY_FID — All the attributes from the Input Features but only the FID from the Identity Features will be transferred to the Output Feature Class.</ows:Abstract>
|
||||
<LiteralData>
|
||||
<ows:DataType ows:reference="xs:string"></ows:DataType>
|
||||
<ows:AllowedValues>
|
||||
<ows:Value>ALL</ows:Value>
|
||||
<ows:Value>NO_FID</ows:Value>
|
||||
<ows:Value>ONLY_FID</ows:Value>
|
||||
</ows:AllowedValues>
|
||||
</LiteralData>
|
||||
</Input>
|
||||
<Input minOccurs="0" maxOccurs="1">
|
||||
<ows:Identifier>cluster_tolerance</ows:Identifier><!-- 4 -->
|
||||
<ows:Title>cluster tolerance</ows:Title>
|
||||
<ows:Abstract>The minimum distance separating all feature coordinates (nodes and vertices) as well as the distance a coordinate can move in X or Y (or both). You can set the value to be higher for data that has less coordinate accuracy and lower for datasets with extremely high accuracy.</ows:Abstract>
|
||||
<LiteralData>
|
||||
<ows:DataType ows:reference="xs:string"></ows:DataType>
|
||||
<ows:AnyValue/>
|
||||
</LiteralData>
|
||||
</Input>
|
||||
<Input minOccurs="0" maxOccurs="1">
|
||||
<ows:Identifier>relationship</ows:Identifier><!-- 5 -->
|
||||
<ows:Title>relationship</ows:Title>
|
||||
<ows:Abstract>Choose if you want additional spatial relationships between the Input Features and Identity Features to be written to the output. This only applies when the Input Features are lines and the Identity Features are polygons. NO_RELATIONSHIPS — No additional spatial relationship will be determined. KEEP_RELATIONSHIPS — Left and right polygon information will be determined for line on polygon identity and written into the RIGHT_poly, LEFT_poly field in the output.</ows:Abstract>
|
||||
<LiteralData>
|
||||
<ows:DataType ows:reference="xs:string"></ows:DataType>
|
||||
<ows:AllowedValues>
|
||||
<ows:Value>NO_RELATIONSHIPS</ows:Value>
|
||||
<ows:Value>KEEP_RELATIONSHIPS</ows:Value>
|
||||
</ows:AllowedValues>
|
||||
</LiteralData>
|
||||
</Input>
|
||||
</DataInputs>
|
||||
<ProcessOutputs>
|
||||
<Output>
|
||||
<ows:Identifier>out_feature_class</ows:Identifier><!-- 2 -->
|
||||
<ows:Title>out feature class</ows:Title>
|
||||
<ows:Abstract>The feature class that will be created and to which the results will be written.</ows:Abstract>
|
||||
<ComplexOutput>
|
||||
<Default>
|
||||
<Format>
|
||||
<MimeType>application/x-zipped-shp</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Default>
|
||||
<Supported>
|
||||
<Format>
|
||||
<MimeType>application/x-zipped-shp</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
<Format>
|
||||
<MimeType>text/XML</MimeType>
|
||||
<Schema>http://schemas.opengis.net/gml/2.1.2/feature.xsd</Schema>
|
||||
</Format>
|
||||
</Supported>
|
||||
</ComplexOutput>
|
||||
</Output>
|
||||
</ProcessOutputs>
|
||||
</ProcessDescription>
|
||||
</wps:ProcessDescriptions>
|
||||
|
||||
|
||||
@ -1,92 +0,0 @@
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<wps:ProcessDescriptions xmlns:wps="http://www.opengis.net/wps/1.0.0" xmlns:ows="http://www.opengis.net/ows/1.1" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.opengis.net/wps/1.0.0
|
||||
http://schemas.opengis.net/wps/1.0.0/wpsDescribeProcess_response.xsd" xml:lang="en-US" service="WPS" version="1.0.0">
|
||||
<ProcessDescription wps:processVersion="2" statusSupported="true" storeSupported="true">
|
||||
<ows:Identifier>org.n52.wps.ags.analysis.overlay.intersect</ows:Identifier><!-- ParameterCount=5 -->
|
||||
<ows:Title>Intersect_analysis</ows:Title>
|
||||
<ows:Abstract>Computes a geometric intersection of the Input Features. Features or portions of features which overlap in all layers and/or feature classes will be written to the Output Feature Class. Uses ArcObjects library - Analysis</ows:Abstract>
|
||||
<DataInputs>
|
||||
<Input minOccurs="1" maxOccurs="1000">
|
||||
<ows:Identifier>in_features</ows:Identifier><!-- 0 -->
|
||||
<ows:Title>in features</ows:Title>
|
||||
<ows:Abstract>A list of the input feature classes or layers. When the distance between features is less than the cluster tolerance, the features with the lower rank will snap to the feature with the higher rank. The highest rank is one. For more information, see Priority ranks and Geoprocessing tools. With ArcView and ArcEditor licenses, the number of input feature classes or layers is limited to two.</ows:Abstract>
|
||||
<ComplexData>
|
||||
<Default>
|
||||
<Format>
|
||||
<MimeType>application/x-zipped-shp</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Default>
|
||||
<Supported>
|
||||
<Format>
|
||||
<MimeType>application/x-zipped-shp</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Supported>
|
||||
</ComplexData>
|
||||
</Input>
|
||||
<Input minOccurs="0" maxOccurs="1">
|
||||
<ows:Identifier>join_attributes</ows:Identifier><!-- 2 -->
|
||||
<ows:Title>join attributes</ows:Title>
|
||||
<ows:Abstract>Determines what attributes will be transferred to the Output Feature Class. ALL — All the attributes (including FIDs) from the Input Features as well as the Identity Features will be transferred to the Output Feature Class. This is the default. NO_FID — All the attributes except the FID from the Input Features and Identity Features will be transferred to the Output Feature Class. ONLY_FID — All the attributes from the Input Features but only the FID from the Identity Features will be transferred to the Output Feature Class.</ows:Abstract>
|
||||
<LiteralData>
|
||||
<ows:DataType ows:reference="xs:string"></ows:DataType>
|
||||
<ows:AllowedValues>
|
||||
<ows:Value>ALL</ows:Value>
|
||||
<ows:Value>NO_FID</ows:Value>
|
||||
<ows:Value>ONLY_FID</ows:Value>
|
||||
</ows:AllowedValues>
|
||||
</LiteralData>
|
||||
</Input>
|
||||
<Input minOccurs="0" maxOccurs="1">
|
||||
<ows:Identifier>cluster_tolerance</ows:Identifier><!-- 3 -->
|
||||
<ows:Title>cluster tolerance</ows:Title>
|
||||
<ows:Abstract>The minimum distance separating all feature coordinates (nodes and vertices) as well as the distance a coordinate can move in X or Y (or both). You can set the value to be higher for data that has less coordinate accuracy and lower for datasets with extremely high accuracy.</ows:Abstract>
|
||||
<LiteralData>
|
||||
<ows:DataType ows:reference="xs:string"></ows:DataType>
|
||||
<ows:AnyValue/>
|
||||
</LiteralData>
|
||||
</Input>
|
||||
<Input minOccurs="0" maxOccurs="1">
|
||||
<ows:Identifier>output_type</ows:Identifier><!-- 4 -->
|
||||
<ows:Title>output type</ows:Title>
|
||||
<ows:Abstract>Choose what type of intersection you want to find. INPUT — The intersections returned will be the same geometry type as the Input Features with the lowest dimension geometry. If all inputs are polygons, the output feature class will contain polygons. If one or more of the inputs are lines and none of the inputs are points, the output will be line. If one or more of the inputs are points, the output feature class will contain points. This is the default. LINE — Line intersections will be returned. This is only valid if none of the inputs are points. POINT — Point intersections will be returned.</ows:Abstract>
|
||||
<LiteralData>
|
||||
<ows:DataType ows:reference="xs:string"></ows:DataType>
|
||||
<ows:AllowedValues>
|
||||
<ows:Value>INPUT</ows:Value>
|
||||
<ows:Value>LINE</ows:Value>
|
||||
<ows:Value>POINT</ows:Value>
|
||||
</ows:AllowedValues>
|
||||
</LiteralData>
|
||||
</Input>
|
||||
</DataInputs>
|
||||
<ProcessOutputs>
|
||||
<Output>
|
||||
<ows:Identifier>out_feature_class</ows:Identifier><!-- 1 -->
|
||||
<ows:Title>out feature class</ows:Title>
|
||||
<ows:Abstract>The feature class to which the results will be written.</ows:Abstract>
|
||||
<ComplexOutput>
|
||||
<Default>
|
||||
<Format>
|
||||
<MimeType>application/x-zipped-shp</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Default>
|
||||
<Supported>
|
||||
<Format>
|
||||
<MimeType>application/x-zipped-shp</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
<Format>
|
||||
<MimeType>text/XML</MimeType>
|
||||
<Schema>http://schemas.opengis.net/gml/2.1.2/feature.xsd</Schema>
|
||||
</Format>
|
||||
</Supported>
|
||||
</ComplexOutput>
|
||||
</Output>
|
||||
</ProcessOutputs>
|
||||
</ProcessDescription>
|
||||
</wps:ProcessDescriptions>
|
||||
|
||||
|
||||
@ -1,145 +0,0 @@
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<wps:ProcessDescriptions xmlns:wps="http://www.opengis.net/wps/1.0.0" xmlns:ows="http://www.opengis.net/ows/1.1" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.opengis.net/wps/1.0.0
|
||||
http://schemas.opengis.net/wps/1.0.0/wpsDescribeProcess_response.xsd" xml:lang="en-US" service="WPS" version="1.0.0">
|
||||
<ProcessDescription wps:processVersion="2" statusSupported="true" storeSupported="true">
|
||||
<ows:Identifier>org.n52.wps.ags.analysis.overlay.spatialjoin</ows:Identifier><!-- ParameterCount=9 -->
|
||||
<ows:Title>SpatialJoin_analysis</ows:Title>
|
||||
<ows:Abstract>This creates a table join in which fields from one layer's attribute table are appended to another layer's attribute table based on the relative locations of the features in the two layers. Uses ArcObjects library - Analysis</ows:Abstract>
|
||||
<DataInputs>
|
||||
<Input minOccurs="1" maxOccurs="1">
|
||||
<ows:Identifier>target_features</ows:Identifier><!-- 0 -->
|
||||
<ows:Title>target features</ows:Title>
|
||||
<ows:Abstract>The dataset that you are joining to. The output of the join operation will contain the features from this feature class with appended columns from the join feature class. It can be any spatial data source (shapefiles, SDE feature classes, coverages, SDC, query tables, etc.) supported by ArcGIS. It can also be read-only.</ows:Abstract>
|
||||
<ComplexData>
|
||||
<Default>
|
||||
<Format>
|
||||
<MimeType>application/x-zipped-shp</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Default>
|
||||
<Supported>
|
||||
<Format>
|
||||
<MimeType>application/x-zipped-shp</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Supported>
|
||||
</ComplexData>
|
||||
</Input>
|
||||
<Input minOccurs="1" maxOccurs="1">
|
||||
<ows:Identifier>join_features</ows:Identifier><!-- 1 -->
|
||||
<ows:Title>join features</ows:Title>
|
||||
<ows:Abstract>The dataset that you are joining from. The attributes from this dataset are appended to the attributes of the target feature class in the output based on a spatial relation. It can be any spatial data source (shapefiles, SDE feature classes, coverages, SDC, query tables, etc.) supported by ArcGIS. It can also be read-only.</ows:Abstract>
|
||||
<ComplexData>
|
||||
<Default>
|
||||
<Format>
|
||||
<MimeType>application/x-zipped-shp</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Default>
|
||||
<Supported>
|
||||
<Format>
|
||||
<MimeType>application/x-zipped-shp</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Supported>
|
||||
</ComplexData>
|
||||
</Input>
|
||||
<Input minOccurs="0" maxOccurs="1">
|
||||
<ows:Identifier>join_operation</ows:Identifier><!-- 3 -->
|
||||
<ows:Title>join operation</ows:Title>
|
||||
<ows:Abstract>The join operation describes cardinality rules associated with matching features during the join. The join options are JOIN_ONE_TO_ONE — This means that the number of rows in the output matches the number of rows in the target feature class. If more than one feature from the join feature class matches a target feature, the attributes of the join features are aggregated in the result. For example, a point within polygon join where several points are within a single polygon results in the aggregation of the points attributes. The aggregation is based on the options set in the field map control. This is the default. JOIN_ONE_TO_MANY — The means that for each row in the target feature class, there can be several rows in the output feature class. With this option, attributes are never aggregated. For example, a point within polygon join where several points are within a single polygon results in a polygon for each matching point in the output feature class.</ows:Abstract>
|
||||
<LiteralData>
|
||||
<ows:DataType ows:reference="xs:string"></ows:DataType>
|
||||
<ows:AllowedValues>
|
||||
<ows:Value>JOIN_ONE_TO_ONE</ows:Value>
|
||||
<ows:Value>JOIN_ONE_TO_MANY</ows:Value>
|
||||
</ows:AllowedValues>
|
||||
</LiteralData>
|
||||
</Input>
|
||||
<Input minOccurs="0" maxOccurs="1">
|
||||
<ows:Identifier>join_type</ows:Identifier><!-- 4 -->
|
||||
<ows:Title>join type</ows:Title>
|
||||
<ows:Abstract>Determine if the join will be an inner or outer join. KEEP_ALL — All records in the input layer or table view will be included in the output; also known as an outer join. This is the default. KEEP_COMMON — Only those records in the input that match to a row in the join table will be present in the result; also known as an inner join.</ows:Abstract>
|
||||
<LiteralData>
|
||||
<ows:DataType ows:reference="xs:boolean"></ows:DataType>
|
||||
<ows:AnyValue/>
|
||||
</LiteralData>
|
||||
</Input>
|
||||
<Input minOccurs="0" maxOccurs="1">
|
||||
<ows:Identifier>match_option</ows:Identifier><!-- 6 -->
|
||||
<ows:Title>match option</ows:Title>
|
||||
<ows:Abstract>Defines the criteria used to match rows. The match options are: INTERSECTS — Matches join features that intersect target features. CONTAINS — Matches occur when a target feature contains a join feature. Points can't be set as target features and polygons can only be set as join features when the target features are also polygons. IS_WITHIN — Target features within join features are matched. Points can't be set as join features and polygons can only be set as target features when the join features are also polygons. CLOSEST — The Target features will be matched to the closest join feature.</ows:Abstract>
|
||||
<LiteralData>
|
||||
<ows:DataType ows:reference="xs:string"></ows:DataType>
|
||||
<ows:AllowedValues>
|
||||
<ows:Value>INTERSECTS</ows:Value>
|
||||
<ows:Value>CONTAINS</ows:Value>
|
||||
<ows:Value>IS_WITHIN</ows:Value>
|
||||
<ows:Value>CLOSEST</ows:Value>
|
||||
</ows:AllowedValues>
|
||||
</LiteralData>
|
||||
</Input>
|
||||
<Input minOccurs="0" maxOccurs="1">
|
||||
<ows:Identifier>search_radius</ows:Identifier><!-- 7 -->
|
||||
<ows:Title>search radius</ows:Title>
|
||||
<ows:Abstract>Only used when the Match Option is INTERSECT or CLOSEST. Join features that are within this distance of the individual input feature will be considered for the operation. The default search radius is 0. A value of 0 for the Search radius means different things to the Match Option. INTERSECT: Only the join features that INTERSECT the input feature will be included in the join. CLOSEST: All join features will be candidates for each input feature. Basically, a value of 0 here means use all join features.</ows:Abstract>
|
||||
<LiteralData>
|
||||
<ows:DataType ows:reference="xs:string"></ows:DataType>
|
||||
<ows:AllowedValues>
|
||||
<ows:Value>INTERSECT</ows:Value>
|
||||
<ows:Value>CLOSEST</ows:Value>
|
||||
</ows:AllowedValues>
|
||||
</LiteralData>
|
||||
</Input>
|
||||
<Input minOccurs="0" maxOccurs="1">
|
||||
<ows:Identifier>distance_field_name</ows:Identifier><!-- 8 -->
|
||||
<ows:Title>distance field name</ows:Title>
|
||||
<ows:Abstract>The name of a new field to be added to the output feature class. This field will be of type Double and will contain distances between the Target and the closest Join Features. This option is only available when the Match Option parameter is set to CLOSEST. A value of -1 in the Distance Field means there were no Join Features within the distance specified in the Search Radius parameter. If no Distance Field Name is specified, then no field will be added to the output to capture this information.</ows:Abstract>
|
||||
<LiteralData>
|
||||
<ows:DataType ows:reference="xs:string"></ows:DataType>
|
||||
<ows:AnyValue/>
|
||||
</LiteralData>
|
||||
</Input>
|
||||
<Input minOccurs="0" maxOccurs="1">
|
||||
<ows:Identifier>output_type</ows:Identifier><!-- 4 -->
|
||||
<ows:Title>output type</ows:Title>
|
||||
<ows:Abstract>Choose what type of intersection you want to find. INPUT — The intersections returned will be the same geometry type as the Input Features with the lowest dimension geometry. If all inputs are polygons, the output feature class will contain polygons. If one or more of the inputs are lines and none of the inputs are points, the output will be line. If one or more of the inputs are points, the output feature class will contain points. This is the default. LINE — Line intersections will be returned. This is only valid if none of the inputs are points. POINT — Point intersections will be returned.</ows:Abstract>
|
||||
<LiteralData>
|
||||
<ows:DataType ows:reference="xs:string"></ows:DataType>
|
||||
<ows:AllowedValues>
|
||||
<ows:Value>INPUT</ows:Value>
|
||||
<ows:Value>LINE</ows:Value>
|
||||
<ows:Value>POINT</ows:Value>
|
||||
</ows:AllowedValues>
|
||||
</LiteralData>
|
||||
</Input>
|
||||
</DataInputs>
|
||||
<ProcessOutputs>
|
||||
<Output>
|
||||
<ows:Identifier>out_feature_class</ows:Identifier><!-- 2 -->
|
||||
<ows:Title>out feature class</ows:Title>
|
||||
<ows:Abstract>A new dataset which contains the results of the join operation.</ows:Abstract>
|
||||
<ComplexOutput>
|
||||
<Default>
|
||||
<Format>
|
||||
<MimeType>application/x-zipped-shp</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Default>
|
||||
<Supported>
|
||||
<Format>
|
||||
<MimeType>application/x-zipped-shp</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
<Format>
|
||||
<MimeType>text/XML</MimeType>
|
||||
<Schema>http://schemas.opengis.net/gml/2.1.2/feature.xsd</Schema>
|
||||
</Format>
|
||||
</Supported>
|
||||
</ComplexOutput>
|
||||
</Output>
|
||||
</ProcessOutputs>
|
||||
</ProcessDescription>
|
||||
</wps:ProcessDescriptions>
|
||||
|
||||
|
||||
@ -1,98 +0,0 @@
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<wps:ProcessDescriptions xmlns:wps="http://www.opengis.net/wps/1.0.0" xmlns:ows="http://www.opengis.net/ows/1.1" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.opengis.net/wps/1.0.0
|
||||
http://schemas.opengis.net/wps/1.0.0/wpsDescribeProcess_response.xsd" xml:lang="en-US" service="WPS" version="1.0.0">
|
||||
<ProcessDescription wps:processVersion="2" statusSupported="true" storeSupported="true">
|
||||
<ows:Identifier>org.n52.wps.ags.analysis.overlay.symetricaldifference</ows:Identifier><!-- ParameterCount=5 -->
|
||||
<ows:Title>SymDiff_analysis</ows:Title>
|
||||
<ows:Abstract>Computes a geometric intersection of the input and update features. Features or portions of features in the input and update features which do not overlap will be written to the Output Feature Class. Uses ArcObjects library - Analysis</ows:Abstract>
|
||||
<DataInputs>
|
||||
<Input minOccurs="1" maxOccurs="1">
|
||||
<ows:Identifier>in_features</ows:Identifier><!-- 0 -->
|
||||
<ows:Title>in features</ows:Title>
|
||||
<ows:Abstract>The input feature class or layer. Geometry type must be polygon.</ows:Abstract>
|
||||
<ComplexData>
|
||||
<Default>
|
||||
<Format>
|
||||
<MimeType>application/x-zipped-shp</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Default>
|
||||
<Supported>
|
||||
<Format>
|
||||
<MimeType>application/x-zipped-shp</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Supported>
|
||||
</ComplexData>
|
||||
</Input>
|
||||
<Input minOccurs="1" maxOccurs="1">
|
||||
<ows:Identifier>update_features</ows:Identifier><!-- 1 -->
|
||||
<ows:Title>update features</ows:Title>
|
||||
<ows:Abstract>The update feature class or layer. Geometry type must be polygon.</ows:Abstract>
|
||||
<ComplexData>
|
||||
<Default>
|
||||
<Format>
|
||||
<MimeType>application/x-zipped-shp</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Default>
|
||||
<Supported>
|
||||
<Format>
|
||||
<MimeType>application/x-zipped-shp</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Supported>
|
||||
</ComplexData>
|
||||
</Input>
|
||||
<Input minOccurs="0" maxOccurs="1">
|
||||
<ows:Identifier>join_attributes</ows:Identifier><!-- 3 -->
|
||||
<ows:Title>join attributes</ows:Title>
|
||||
<ows:Abstract>Determines what attributes will be transferred to the Output Feature Class. ALL — All the attributes (including FIDs) from the Input Features as well as the Identity Features will be transferred to the Output Feature Class. This is the default. NO_FID — All the attributes except the FID from the Input Features and Identity Features will be transferred to the Output Feature Class. ONLY_FID — All the attributes from the Input Features but only the FID from the Identity Features will be transferred to the Output Feature Class.</ows:Abstract>
|
||||
<LiteralData>
|
||||
<ows:DataType ows:reference="xs:string"></ows:DataType>
|
||||
<ows:AllowedValues>
|
||||
<ows:Value>ALL</ows:Value>
|
||||
<ows:Value>NO_FID</ows:Value>
|
||||
<ows:Value>ONLY_FID</ows:Value>
|
||||
</ows:AllowedValues>
|
||||
</LiteralData>
|
||||
</Input>
|
||||
<Input minOccurs="0" maxOccurs="1">
|
||||
<ows:Identifier>cluster_tolerance</ows:Identifier><!-- 4 -->
|
||||
<ows:Title>cluster tolerance</ows:Title>
|
||||
<ows:Abstract>The minimum distance separating all feature coordinates (nodes and vertices) as well as the distance a coordinate can move in X or Y (or both). You can set the value to be higher for data that has less coordinate accuracy and lower for datasets with extremely high accuracy.</ows:Abstract>
|
||||
<LiteralData>
|
||||
<ows:DataType ows:reference="xs:string"></ows:DataType>
|
||||
<ows:AnyValue/>
|
||||
</LiteralData>
|
||||
</Input>
|
||||
</DataInputs>
|
||||
<ProcessOutputs>
|
||||
<Output>
|
||||
<ows:Identifier>out_feature_class</ows:Identifier><!-- 2 -->
|
||||
<ows:Title>out feature class</ows:Title>
|
||||
<ows:Abstract>The feature class to which the results will be written.</ows:Abstract>
|
||||
<ComplexOutput>
|
||||
<Default>
|
||||
<Format>
|
||||
<MimeType>application/x-zipped-shp</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Default>
|
||||
<Supported>
|
||||
<Format>
|
||||
<MimeType>application/x-zipped-shp</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
<Format>
|
||||
<MimeType>text/XML</MimeType>
|
||||
<Schema>http://schemas.opengis.net/gml/2.1.2/feature.xsd</Schema>
|
||||
</Format>
|
||||
</Supported>
|
||||
</ComplexOutput>
|
||||
</Output>
|
||||
</ProcessOutputs>
|
||||
</ProcessDescription>
|
||||
</wps:ProcessDescriptions>
|
||||
|
||||
|
||||
@ -1,88 +0,0 @@
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<wps:ProcessDescriptions xmlns:wps="http://www.opengis.net/wps/1.0.0" xmlns:ows="http://www.opengis.net/ows/1.1" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.opengis.net/wps/1.0.0
|
||||
http://schemas.opengis.net/wps/1.0.0/wpsDescribeProcess_response.xsd" xml:lang="en-US" service="WPS" version="1.0.0">
|
||||
<ProcessDescription wps:processVersion="2" statusSupported="true" storeSupported="true">
|
||||
<ows:Identifier>org.n52.wps.ags.analysis.overlay.union</ows:Identifier><!-- ParameterCount=5 -->
|
||||
<ows:Title>Union_analysis</ows:Title>
|
||||
<ows:Abstract>Computes a geometric intersection of the Input Features. All features will be written to the Output Feature Class with the attributes from the Input Features, which it overlaps. Uses ArcObjects library - Analysis</ows:Abstract>
|
||||
<DataInputs>
|
||||
<Input minOccurs="1" maxOccurs="1000">
|
||||
<ows:Identifier>in_features</ows:Identifier><!-- 0 -->
|
||||
<ows:Title>in features</ows:Title>
|
||||
<ows:Abstract>A list of the input feature classes or layers. When the distance between features is less than the cluster tolerance, the features with the lower rank will snap to the feature with the higher rank. The highest rank is one. All the Input Features must be polygons. With ArcView and ArcEditor licenses, the number of input feature classes or layers is limited to two.</ows:Abstract>
|
||||
<ComplexData>
|
||||
<Default>
|
||||
<Format>
|
||||
<MimeType>application/x-zipped-shp</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Default>
|
||||
<Supported>
|
||||
<Format>
|
||||
<MimeType>application/x-zipped-shp</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Supported>
|
||||
</ComplexData>
|
||||
</Input>
|
||||
<Input minOccurs="0" maxOccurs="1">
|
||||
<ows:Identifier>join_attributes</ows:Identifier><!-- 2 -->
|
||||
<ows:Title>join attributes</ows:Title>
|
||||
<ows:Abstract>Determines what attributes will be transferred to the Output Feature Class. ALL — All the attributes (including FIDs) from the Input Features as well as the Identity Features will be transferred to the Output Feature Class. This is the default. NO_FID — All the attributes except the FID from the Input Features and Identity Features will be transferred to the Output Feature Class. ONLY_FID — All the attributes from the Input Features but only the FID from the Identity Features will be transferred to the Output Feature Class.</ows:Abstract>
|
||||
<LiteralData>
|
||||
<ows:DataType ows:reference="xs:string"></ows:DataType>
|
||||
<ows:AllowedValues>
|
||||
<ows:Value>ALL</ows:Value>
|
||||
<ows:Value>NO_FID</ows:Value>
|
||||
<ows:Value>ONLY_FID</ows:Value>
|
||||
</ows:AllowedValues>
|
||||
</LiteralData>
|
||||
</Input>
|
||||
<Input minOccurs="0" maxOccurs="1">
|
||||
<ows:Identifier>cluster_tolerance</ows:Identifier><!-- 3 -->
|
||||
<ows:Title>cluster tolerance</ows:Title>
|
||||
<ows:Abstract>The minimum distance separating all feature coordinates (nodes and vertices) as well as the distance a coordinate can move in X or Y (or both). You can set the value to be higher for data that has less coordinate accuracy and lower for datasets with extremely high accuracy.</ows:Abstract>
|
||||
<LiteralData>
|
||||
<ows:DataType ows:reference="xs:string"></ows:DataType>
|
||||
<ows:AnyValue/>
|
||||
</LiteralData>
|
||||
</Input>
|
||||
<Input minOccurs="0" maxOccurs="1">
|
||||
<ows:Identifier>gaps</ows:Identifier><!-- 4 -->
|
||||
<ows:Title>gaps</ows:Title>
|
||||
<ows:Abstract>Gaps are areas in the output feature class that are completely enclosed by other polygons. This is not invalid, but it may be desirable to identify these for analysis. To find the gaps in the output, set this option to NO_GAPS, and a feature will be created in these areas. To select these features, query the output feature class based on all the input feature's FID values being equal to -1. GAPS — No feature will be created for areas in the output that are completely enclosed by polygons. This is the default. NO_GAPS — A feature will be created for the areas in the output that are completely enclosed by polygons. This feature will have blank attributes.
|
||||
</ows:Abstract>
|
||||
<LiteralData>
|
||||
<ows:DataType ows:reference="xs:boolean"></ows:DataType>
|
||||
<ows:AnyValue/>
|
||||
</LiteralData>
|
||||
</Input>
|
||||
</DataInputs>
|
||||
<ProcessOutputs>
|
||||
<Output>
|
||||
<ows:Identifier>out_feature_class</ows:Identifier><!-- 2 -->
|
||||
<ows:Title>out feature class</ows:Title>
|
||||
<ows:Abstract>The feature class that will contain the results.</ows:Abstract>
|
||||
<ComplexOutput>
|
||||
<Default>
|
||||
<Format>
|
||||
<MimeType>application/x-zipped-shp</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Default>
|
||||
<Supported>
|
||||
<Format>
|
||||
<MimeType>application/x-zipped-shp</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
<Format>
|
||||
<MimeType>text/XML</MimeType>
|
||||
<Schema>http://schemas.opengis.net/gml/2.1.2/feature.xsd</Schema>
|
||||
</Format>
|
||||
</Supported>
|
||||
</ComplexOutput>
|
||||
</Output>
|
||||
</ProcessOutputs>
|
||||
</ProcessDescription>
|
||||
</wps:ProcessDescriptions>
|
||||
|
||||
@ -1,95 +0,0 @@
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<wps:ProcessDescriptions xmlns:wps="http://www.opengis.net/wps/1.0.0" xmlns:ows="http://www.opengis.net/ows/1.1" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.opengis.net/wps/1.0.0
|
||||
http://schemas.opengis.net/wps/1.0.0/wpsDescribeProcess_response.xsd" xml:lang="en-US" service="WPS" version="1.0.0">
|
||||
<ProcessDescription wps:processVersion="2" statusSupported="true" storeSupported="true">
|
||||
<ows:Identifier>org.n52.wps.ags.analysis.overlay.update</ows:Identifier><!-- ParameterCount=5 -->
|
||||
<ows:Title>Union_analysis</ows:Title>
|
||||
<ows:Abstract>Computes a geometric intersection of the Input Features and Update Features. The attributes and geometry of the Input Features are updated by the Update Features. The results are written to the Output Feature Class.
|
||||
Uses ArcObjects library - Analysis</ows:Abstract>
|
||||
<DataInputs>
|
||||
<Input minOccurs="1" maxOccurs="1">
|
||||
<ows:Identifier>in_features</ows:Identifier><!-- 0 -->
|
||||
<ows:Title>in features</ows:Title>
|
||||
<ows:Abstract>The input feature class or layer. Geometry type must be polygon.</ows:Abstract>
|
||||
<ComplexData>
|
||||
<Default>
|
||||
<Format>
|
||||
<MimeType>application/x-zipped-shp</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Default>
|
||||
<Supported>
|
||||
<Format>
|
||||
<MimeType>application/x-zipped-shp</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Supported>
|
||||
</ComplexData>
|
||||
</Input>
|
||||
<Input minOccurs="1" maxOccurs="1">
|
||||
<ows:Identifier>update_features</ows:Identifier><!-- 1 -->
|
||||
<ows:Title>update features</ows:Title>
|
||||
<ows:Abstract>The features that will be used to update the Input features. Geometry type must be polygon.</ows:Abstract>
|
||||
<ComplexData>
|
||||
<Default>
|
||||
<Format>
|
||||
<MimeType>application/x-zipped-shp</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Default>
|
||||
<Supported>
|
||||
<Format>
|
||||
<MimeType>application/x-zipped-shp</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Supported>
|
||||
</ComplexData>
|
||||
</Input>
|
||||
<Input minOccurs="0" maxOccurs="1">
|
||||
<ows:Identifier>keep_borders</ows:Identifier><!-- 3 -->
|
||||
<ows:Title>keep borders</ows:Title>
|
||||
<ows:Abstract>Specifies whether the boundary of the update polygon features will be kept. KEEP_BORDER — The outside border of the Update Features will be kept in the Output Feature Class. This is the default option. DROP_BORDER — The outside borders of the Update Features are dropped after they are inserted into the Input Features. Item values of the Update Features take precedence over input feature attributes.</ows:Abstract>
|
||||
<LiteralData>
|
||||
<ows:DataType ows:reference="xs:boolean"></ows:DataType>
|
||||
<ows:AnyValue/>
|
||||
</LiteralData>
|
||||
</Input>
|
||||
<Input minOccurs="0" maxOccurs="1">
|
||||
<ows:Identifier>cluster_tolerance</ows:Identifier><!-- 4 -->
|
||||
<ows:Title>cluster tolerance</ows:Title>
|
||||
<ows:Abstract>The minimum distance separating all feature coordinates (nodes and vertices) as well as the distance a coordinate can move in X or Y (or both). You can set the value to be higher for data that has less coordinate accuracy and lower for datasets with extremely high accuracy.</ows:Abstract>
|
||||
<LiteralData>
|
||||
<ows:DataType ows:reference="xs:string"></ows:DataType>
|
||||
<ows:AnyValue/>
|
||||
</LiteralData>
|
||||
</Input>
|
||||
</DataInputs>
|
||||
<ProcessOutputs>
|
||||
<Output>
|
||||
<ows:Identifier>out_feature_class</ows:Identifier><!-- 2 -->
|
||||
<ows:Title>out feature class</ows:Title>
|
||||
<ows:Abstract>The feature class to contain the results. Do not set this to be the same as the Input Features.</ows:Abstract>
|
||||
<ComplexOutput>
|
||||
<Default>
|
||||
<Format>
|
||||
<MimeType>application/x-zipped-shp</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Default>
|
||||
<Supported>
|
||||
<Format>
|
||||
<MimeType>application/x-zipped-shp</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
<Format>
|
||||
<MimeType>text/XML</MimeType>
|
||||
<Schema>http://schemas.opengis.net/gml/2.1.2/feature.xsd</Schema>
|
||||
</Format>
|
||||
</Supported>
|
||||
</ComplexOutput>
|
||||
</Output>
|
||||
</ProcessOutputs>
|
||||
</ProcessDescription>
|
||||
</wps:ProcessDescriptions>
|
||||
|
||||
|
||||
@ -1,114 +0,0 @@
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<wps:ProcessDescriptions xmlns:wps="http://www.opengis.net/wps/1.0.0" xmlns:ows="http://www.opengis.net/ows/1.1" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.opengis.net/wps/1.0.0
|
||||
http://schemas.opengis.net/wps/1.0.0/wpsDescribeProcess_response.xsd" xml:lang="en-US" service="WPS" version="1.0.0">
|
||||
<ProcessDescription wps:processVersion="2" statusSupported="true" storeSupported="true">
|
||||
<ows:Identifier>org.n52.wps.ags.analysis.proximity.buffer</ows:Identifier><!-- ParameterCount=7 -->
|
||||
<ows:Title>Buffer_analysis</ows:Title>
|
||||
<ows:Abstract>Creates buffer polygons to a specified distance around the Input Features. An optional dissolve can be performed to remove overlapping buffers. Uses ArcObjects library - Analysis</ows:Abstract>
|
||||
<DataInputs>
|
||||
<Input minOccurs="1" maxOccurs="1">
|
||||
<ows:Identifier>in_features</ows:Identifier><!-- 0 -->
|
||||
<ows:Title>in features</ows:Title>
|
||||
<ows:Abstract>The feature layer or feature class to be buffered.</ows:Abstract>
|
||||
<ComplexData>
|
||||
<Default>
|
||||
<Format>
|
||||
<MimeType>application/x-zipped-shp</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Default>
|
||||
<Supported>
|
||||
<Format>
|
||||
<MimeType>application/x-zipped-shp</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Supported>
|
||||
</ComplexData>
|
||||
</Input>
|
||||
<Input minOccurs="1" maxOccurs="1">
|
||||
<ows:Identifier>buffer_distance_or_field</ows:Identifier><!-- 2 -->
|
||||
<ows:Title>buffer distance or field</ows:Title>
|
||||
<ows:Abstract>The distance used to create buffer zones around Input Features. Either a value or a numeric field can be used to provide buffer distances. If a negative buffer distance is specified, the buffer offsets will be generated inside, instead of outside, of the input features. This is only valid for polygon feature classes. If the distance units are not specified, or entered as Unknown, the units of the Input Features are used (or if the Output Coordinate System environment has been set, its units will be used).</ows:Abstract>
|
||||
<LiteralData>
|
||||
<ows:DataType ows:reference="xs:string"></ows:DataType>
|
||||
<ows:AnyValue/>
|
||||
</LiteralData>
|
||||
</Input>
|
||||
<Input minOccurs="0" maxOccurs="1">
|
||||
<ows:Identifier>line_side</ows:Identifier><!-- 3 -->
|
||||
<ows:Title>line side</ows:Title>
|
||||
<ows:Abstract>Options to buffer to one side of a line or outside polygons: FULL — A buffer will be generated on both sides of the line. If the input is a polygon, the result will include the area inside the polygon. This is the default. LEFT — The buffer will be generated on the LEFT side of the line. RIGHT — The buffer will be generated on the RIGHT side of the line. OUTSIDE_ONLY — The area inside the input polygon features will be excluded from the resulting buffer. These options are not available with an ArcView or ArcEditor license.</ows:Abstract>
|
||||
<LiteralData>
|
||||
<ows:DataType ows:reference="xs:string"></ows:DataType>
|
||||
<ows:AllowedValues>
|
||||
<ows:Value>FULL</ows:Value>
|
||||
<ows:Value>LEFT</ows:Value>
|
||||
<ows:Value>RIGHT</ows:Value>
|
||||
<ows:Value>OUTSIDE_ONLY</ows:Value>
|
||||
</ows:AllowedValues>
|
||||
</LiteralData>
|
||||
</Input>
|
||||
<Input minOccurs="0" maxOccurs="1">
|
||||
<ows:Identifier>line_end_type</ows:Identifier><!-- 4 -->
|
||||
<ows:Title>line end type</ows:Title>
|
||||
<ows:Abstract>For lines, the shape of the buffer at the line end points. ROUND — End will be in the shape of a half circle. This is the default. FLAT — Creates rectangular line endings with the middle of the short side of the rectangle coincident with the end point of the line. These options are not available with an ArcView or ArcEditor license. Line buffers will always have ROUND ends.</ows:Abstract>
|
||||
<LiteralData>
|
||||
<ows:DataType ows:reference="xs:string"></ows:DataType>
|
||||
<ows:AllowedValues>
|
||||
<ows:Value>ROUND</ows:Value>
|
||||
<ows:Value>FLAT</ows:Value>
|
||||
</ows:AllowedValues>
|
||||
</LiteralData>
|
||||
</Input>
|
||||
<Input minOccurs="0" maxOccurs="1">
|
||||
<ows:Identifier>dissolve_option</ows:Identifier><!-- 5 -->
|
||||
<ows:Title>dissolve option</ows:Title>
|
||||
<ows:Abstract>Specifies whether a dissolve will be performed to remove buffer feature overlap. NONE — Individual buffer for each feature is maintained, regardless of overlap. This is the default. ALL — Dissolves all the buffers together into a single feature and removes any overlap. LIST — Dissolves by a given list of fields.</ows:Abstract>
|
||||
<LiteralData>
|
||||
<ows:DataType ows:reference="xs:string"></ows:DataType>
|
||||
<ows:AllowedValues>
|
||||
<ows:Value>NONE</ows:Value>
|
||||
<ows:Value>ALL</ows:Value>
|
||||
<ows:Value>LIST</ows:Value>
|
||||
</ows:AllowedValues>
|
||||
</LiteralData>
|
||||
</Input>
|
||||
<Input minOccurs="0" maxOccurs="1">
|
||||
<ows:Identifier>dissolve_field</ows:Identifier><!-- 6 -->
|
||||
<ows:Title>dissolve field</ows:Title>
|
||||
<ows:Abstract>List of field(s) for the dissolve. Buffer polygons that share the same set of values in their Dissolve Field(s) will be dissolved together. The Add Field button, which is used only in ModelBuilder, allows you to add expected fields so you can complete the dialog box and continue to build your model.</ows:Abstract>
|
||||
<LiteralData>
|
||||
<ows:DataType ows:reference="xs:string"></ows:DataType>
|
||||
<ows:AnyValue/>
|
||||
</LiteralData>
|
||||
</Input>
|
||||
</DataInputs>
|
||||
<ProcessOutputs>
|
||||
<Output>
|
||||
<ows:Identifier>out_feature_class</ows:Identifier><!-- 1 -->
|
||||
<ows:Title>out feature class</ows:Title>
|
||||
<ows:Abstract>The feature class that will be created and to which the resulting features will be written.</ows:Abstract>
|
||||
<ComplexOutput>
|
||||
<Default>
|
||||
<Format>
|
||||
<MimeType>application/x-zipped-shp</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Default>
|
||||
<Supported>
|
||||
<Format>
|
||||
<MimeType>application/x-zipped-shp</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
<Format>
|
||||
<MimeType>text/XML</MimeType>
|
||||
<Schema>http://schemas.opengis.net/gml/2.1.2/feature.xsd</Schema>
|
||||
</Format>
|
||||
</Supported>
|
||||
</ComplexOutput>
|
||||
</Output>
|
||||
</ProcessOutputs>
|
||||
</ProcessDescription>
|
||||
</wps:ProcessDescriptions>
|
||||
|
||||
|
||||
@ -1,70 +0,0 @@
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<wps:ProcessDescriptions xmlns:wps="http://www.opengis.net/wps/1.0.0" xmlns:ows="http://www.opengis.net/ows/1.1" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.opengis.net/wps/1.0.0
|
||||
http://schemas.opengis.net/wps/1.0.0/wpsDescribeProcess_response.xsd" xml:lang="en-US" service="WPS" version="1.0.0">
|
||||
<ProcessDescription wps:processVersion="2" statusSupported="true" storeSupported="true">
|
||||
<ows:Identifier>org.n52.wps.ags.analysis.proximity.createthiessenpolygons</ows:Identifier><!-- ParameterCount=3 -->
|
||||
<ows:Title>CreateThiessenPolygons_analysis</ows:Title>
|
||||
<ows:Abstract>This converts input points to an output feature class of Thiessen proximal polygons.
|
||||
Thiessen polygons have the unique property that each polygon contains only one input point, and any location within a polygon is closer to its associated point than to the point of any other polygon. Uses ArcObjects library - Analysis</ows:Abstract>
|
||||
<DataInputs>
|
||||
<Input minOccurs="1" maxOccurs="1">
|
||||
<ows:Identifier>in_features</ows:Identifier><!-- 0 -->
|
||||
<ows:Title>in features</ows:Title>
|
||||
<ows:Abstract>The points for which the Thiessen polygons will be generated.</ows:Abstract>
|
||||
<ComplexData>
|
||||
<Default>
|
||||
<Format>
|
||||
<MimeType>application/x-zipped-shp</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Default>
|
||||
<Supported>
|
||||
<Format>
|
||||
<MimeType>application/x-zipped-shp</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Supported>
|
||||
</ComplexData>
|
||||
</Input>
|
||||
<Input minOccurs="0" maxOccurs="1">
|
||||
<ows:Identifier>fields_to_copy</ows:Identifier><!-- 2 -->
|
||||
<ows:Title>fields to copy</ows:Title>
|
||||
<ows:Abstract>Determines which attributes from the Input Features will be transferred to the Output Feature Class. ONLY_FID — Only the FID field from the Input Features will be transferred to the Output Feature Class. This is the default. ALL — All the attributes from the Input Features will be transferred to the Output Feature Class.</ows:Abstract>
|
||||
<LiteralData>
|
||||
<ows:DataType ows:reference="xs:string"></ows:DataType>
|
||||
<ows:AllowedValues>
|
||||
<ows:Value>ONLY_FID</ows:Value>
|
||||
<ows:Value>ALL</ows:Value>
|
||||
</ows:AllowedValues>
|
||||
</LiteralData>
|
||||
</Input>
|
||||
</DataInputs>
|
||||
<ProcessOutputs>
|
||||
<Output>
|
||||
<ows:Identifier>out_feature_class</ows:Identifier><!-- 1 -->
|
||||
<ows:Title>out feature class</ows:Title>
|
||||
<ows:Abstract>The polygon feature class that will contain the Thiessen features.</ows:Abstract>
|
||||
<ComplexOutput>
|
||||
<Default>
|
||||
<Format>
|
||||
<MimeType>application/x-zipped-shp</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Default>
|
||||
<Supported>
|
||||
<Format>
|
||||
<MimeType>application/x-zipped-shp</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
<Format>
|
||||
<MimeType>text/XML</MimeType>
|
||||
<Schema>http://schemas.opengis.net/gml/2.1.2/feature.xsd</Schema>
|
||||
</Format>
|
||||
</Supported>
|
||||
</ComplexOutput>
|
||||
</Output>
|
||||
</ProcessOutputs>
|
||||
</ProcessDescription>
|
||||
</wps:ProcessDescriptions>
|
||||
|
||||
|
||||
@ -1,124 +0,0 @@
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<wps:ProcessDescriptions xmlns:wps="http://www.opengis.net/wps/1.0.0" xmlns:ows="http://www.opengis.net/ows/1.1" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.opengis.net/wps/1.0.0
|
||||
http://schemas.opengis.net/wps/1.0.0/wpsDescribeProcess_response.xsd" xml:lang="en-US" service="WPS" version="1.0.0">
|
||||
<ProcessDescription wps:processVersion="2" statusSupported="true" storeSupported="true">
|
||||
<ows:Identifier>org.n52.wps.ags.analysis.proximity.generateneartable</ows:Identifier><!-- ParameterCount=8 -->
|
||||
<ows:Title>GenerateNearTable_analysis</ows:Title>
|
||||
<ows:Abstract>Determines the distance from each feature in the Input Features to the nearest features in the Near Features, within the Search Radius. The results are recorded in the output table. Uses ArcObjects library - Analysis</ows:Abstract>
|
||||
<DataInputs>
|
||||
<Input minOccurs="1" maxOccurs="1">
|
||||
<ows:Identifier>in_features</ows:Identifier><!-- 0 -->
|
||||
<ows:Title>in features</ows:Title>
|
||||
<ows:Abstract>The feature class or layer containing features from which near distances are calculated to each feature in the Near Features.</ows:Abstract>
|
||||
<ComplexData>
|
||||
<Default>
|
||||
<Format>
|
||||
<MimeType>application/x-zipped-shp</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Default>
|
||||
<Supported>
|
||||
<Format>
|
||||
<MimeType>application/x-zipped-shp</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Supported>
|
||||
</ComplexData>
|
||||
</Input>
|
||||
<Input minOccurs="1" maxOccurs="1">
|
||||
<ows:Identifier>near_features</ows:Identifier><!-- 1 -->
|
||||
<ows:Title>near features</ows:Title>
|
||||
<ows:Abstract>The feature class or layer containing features from which distances are calculated to the closest feature in the Input Features. If multiple feature classes or layers are specified, an extra field named NEAR_FC will be added to the output table to identify which near feature class contains the closest feature.</ows:Abstract>
|
||||
<ComplexData>
|
||||
<Default>
|
||||
<Format>
|
||||
<MimeType>application/x-zipped-shp</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Default>
|
||||
<Supported>
|
||||
<Format>
|
||||
<MimeType>application/x-zipped-shp</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Supported>
|
||||
</ComplexData>
|
||||
</Input>
|
||||
<Input minOccurs="0" maxOccurs="1">
|
||||
<ows:Identifier>search radius</ows:Identifier><!-- 3 -->
|
||||
<ows:Title>search radius</ows:Title>
|
||||
<ows:Abstract>The maximum distance between Input Features and Near Features for which distance and FIDs will be determined. If no Search Radius is specified, all Near Features will be used.</ows:Abstract>
|
||||
<LiteralData>
|
||||
<ows:DataType ows:reference="xs:string"></ows:DataType>
|
||||
<ows:AnyValue/>
|
||||
</LiteralData>
|
||||
</Input>
|
||||
<Input minOccurs="0" maxOccurs="1">
|
||||
<ows:Identifier>location</ows:Identifier><!-- 4 -->
|
||||
<ows:Title>location</ows:Title>
|
||||
<ows:Abstract>Determines whether the x,y coordinates of the nearest feature are added to the output table as well as NEAR_FID and NEAR_DIST. The new fields are NEAR_X and NEAR_Y. NO_LOCATION — The x,y coordinates or the nearest point are not saved. This is the default. LOCATION — Additional fields named NEAR_X and NEAR_Y will be added to the output table. These fields will contain the x- and y-coordinates of the Near Features.</ows:Abstract>
|
||||
<LiteralData>
|
||||
<ows:DataType ows:reference="xs:string"></ows:DataType>
|
||||
<ows:AllowedValues>
|
||||
<ows:Value>NEAR_DIST</ows:Value>
|
||||
<ows:Value>NEAR_Y</ows:Value>
|
||||
</ows:AllowedValues>
|
||||
</LiteralData>
|
||||
</Input>
|
||||
<Input minOccurs="0" maxOccurs="1">
|
||||
<ows:Identifier>angle</ows:Identifier><!-- 5 -->
|
||||
<ows:Title>angle</ows:Title>
|
||||
<ows:Abstract>Determines whether the angle between the near feature will be calculated and stored in the NEAR_ANGLE field. The angle value is measured in degrees, where one degree represents 1/360 of a circle, and fractions of a degree are represented as decimal points. Angles are measured from 180° to -180° ; 0° to the east, 90° to the north, 180° (-180° ) to the west, and -90° to the south. NO_ANGLE — The angle between the nearest point will not be saved. This is the default. ANGLE — A field named NEAR_ANGLE will be added to the output table and will contain the angle from the Input to the nearest point on the Near Feature.</ows:Abstract>
|
||||
<LiteralData>
|
||||
<ows:DataType ows:reference="xs:boolean"></ows:DataType>
|
||||
<ows:AnyValue/>
|
||||
</LiteralData>
|
||||
</Input>
|
||||
<Input minOccurs="0" maxOccurs="1">
|
||||
<ows:Identifier>closest</ows:Identifier><!-- 6 -->
|
||||
<ows:Title>closest</ows:Title>
|
||||
<ows:Abstract>Determines whether to locate and return only the closest features or return all the features within the search radius. CLOSEST — Locate and return only the closest features from the Near Features to the Input Features within the search radius. This is the default. ALL — Locate and return all features from the Near Features to the Input Features within the search radius.</ows:Abstract>
|
||||
<LiteralData>
|
||||
<ows:DataType ows:reference="xs:boolean"></ows:DataType>
|
||||
<ows:AnyValue/>
|
||||
</LiteralData>
|
||||
</Input>
|
||||
<Input minOccurs="0" maxOccurs="1">
|
||||
<ows:Identifier>closest_count</ows:Identifier><!-- 7 -->
|
||||
<ows:Title>closest count</ows:Title>
|
||||
<ows:Abstract>Finds only the specified number of closest features. This parameter is disabled if Find only closest feature is selected.</ows:Abstract>
|
||||
<LiteralData>
|
||||
<ows:DataType ows:reference="xs:long"></ows:DataType>
|
||||
<ows:AnyValue/>
|
||||
</LiteralData>
|
||||
</Input>
|
||||
</DataInputs>
|
||||
<ProcessOutputs>
|
||||
<Output>
|
||||
<ows:Identifier>out_table</ows:Identifier><!-- 2 -->
|
||||
<ows:Title>out table</ows:Title>
|
||||
<ows:Abstract>The output table that will contain the proximity information such as INPUT_FID, NEAR_FID, and NEAR_DIST and other attributes such as NEAR_XY, NEAR_ANGLE, and NEAR_FC if necessary.</ows:Abstract>
|
||||
<ComplexOutput>
|
||||
<Default>
|
||||
<Format>
|
||||
<MimeType>application/dbf</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Default>
|
||||
<Supported>
|
||||
<Format>
|
||||
<MimeType>application/dbf</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
<Format>
|
||||
<MimeType>text/XML</MimeType>
|
||||
<Schema>http://schemas.opengis.net/gml/2.1.2/feature.xsd</Schema>
|
||||
</Format>
|
||||
</Supported>
|
||||
</ComplexOutput>
|
||||
</Output>
|
||||
</ProcessOutputs>
|
||||
</ProcessDescription>
|
||||
</wps:ProcessDescriptions>
|
||||
|
||||
|
||||
@ -1,121 +0,0 @@
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<wps:ProcessDescriptions xmlns:wps="http://www.opengis.net/wps/1.0.0" xmlns:ows="http://www.opengis.net/ows/1.1" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.opengis.net/wps/1.0.0
|
||||
http://schemas.opengis.net/wps/1.0.0/wpsDescribeProcess_response.xsd" xml:lang="en-US" service="WPS" version="1.0.0">
|
||||
<ProcessDescription wps:processVersion="2" statusSupported="true" storeSupported="true">
|
||||
<ows:Identifier>org.n52.wps.ags.analysis.proximity.multipleringbuffer</ows:Identifier><!-- ParameterCount=7 -->
|
||||
<ows:Title>MultipleRingBuffer_analysis</ows:Title>
|
||||
<ows:Abstract>Creates a new feature class of buffer features using a set of buffer distances. The new features may be dissolved using the distance values or as a set of individual features. Uses ArcObjects library - Analysis</ows:Abstract>
|
||||
<DataInputs>
|
||||
<Input minOccurs="1" maxOccurs="1">
|
||||
<ows:Identifier>Input_Features</ows:Identifier><!-- 0 -->
|
||||
<ows:Title>Input Features</ows:Title>
|
||||
<ows:Abstract>The feature layer or feature class to be buffered.</ows:Abstract>
|
||||
<ComplexData>
|
||||
<Default>
|
||||
<Format>
|
||||
<MimeType>application/x-zipped-shp</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Default>
|
||||
<Supported>
|
||||
<Format>
|
||||
<MimeType>application/x-zipped-shp</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Supported>
|
||||
</ComplexData>
|
||||
</Input>
|
||||
<Input minOccurs="1" maxOccurs="1">
|
||||
<ows:Identifier>Distances</ows:Identifier><!-- 2 -->
|
||||
<ows:Title>Distances</ows:Title>
|
||||
<ows:Abstract>The distances, in ascending size, used to create buffer zones around the Input Features.</ows:Abstract>
|
||||
<LiteralData>
|
||||
<ows:DataType ows:reference="xs:double"></ows:DataType>
|
||||
<ows:AnyValue/>
|
||||
</LiteralData>
|
||||
</Input>
|
||||
<Input minOccurs="0" maxOccurs="1">
|
||||
<ows:Identifier>Line_Side</ows:Identifier><!-- 3 -->
|
||||
<ows:Title>Line Side</ows:Title>
|
||||
<ows:Abstract>The units used with the Distance values. Default Centimeters
|
||||
DecimalDegrees Feet Inches Kilometers Meters Miles Millimeters
|
||||
NauticalMiles Points Yards
|
||||
If the units are not specified, or are entered as Default, the units of the Input Features are used (or if the Output Coordinate System environment has been set, its units will be used).</ows:Abstract>
|
||||
<LiteralData>
|
||||
<ows:DataType ows:reference="xs:string"></ows:DataType>
|
||||
<ows:AllowedValues>
|
||||
<ows:Value>Default</ows:Value>
|
||||
<ows:Value>Centimeters</ows:Value>
|
||||
<ows:Value>DecimalDegrees</ows:Value>
|
||||
<ows:Value>Feet</ows:Value>
|
||||
<ows:Value>Inches</ows:Value>
|
||||
<ows:Value>Kilometers</ows:Value>
|
||||
<ows:Value>Meters</ows:Value>
|
||||
<ows:Value>Miles</ows:Value>
|
||||
<ows:Value>Millimeters</ows:Value>
|
||||
<ows:Value>NauticalMiles</ows:Value>
|
||||
<ows:Value>Points</ows:Value>
|
||||
<ows:Value>Yards</ows:Value>
|
||||
</ows:AllowedValues>
|
||||
</LiteralData>
|
||||
</Input>
|
||||
<Input minOccurs="0" maxOccurs="1">
|
||||
<ows:Identifier>Field_Name</ows:Identifier><!-- 4 -->
|
||||
<ows:Title>Field Name</ows:Title>
|
||||
<ows:Abstract>The name of the field in the Output Feature Class that will store the buffer distance used to create each feature. If no value is specified, the name will be distance. The type of the field is double.</ows:Abstract>
|
||||
<LiteralData>
|
||||
<ows:DataType ows:reference="xs:string"></ows:DataType>
|
||||
<ows:AnyValue/>
|
||||
</LiteralData>
|
||||
</Input>
|
||||
<Input minOccurs="0" maxOccurs="1">
|
||||
<ows:Identifier>Dissolve_Option</ows:Identifier><!-- 5 -->
|
||||
<ows:Title>Dissolve Option</ows:Title>
|
||||
<ows:Abstract>Specifies whether a dissolve will be performed to remove buffer feature overlap. NONE — Individual buffer for each feature is maintained, regardless of overlap. This is the default. ALL — Dissolves all the buffers together into a single feature and removes any overlap. LIST — Dissolves by a given list of fields.</ows:Abstract>
|
||||
<LiteralData>
|
||||
<ows:DataType ows:reference="xs:string"></ows:DataType>
|
||||
<ows:AllowedValues>
|
||||
<ows:Value>NONE</ows:Value>
|
||||
<ows:Value>ALL</ows:Value>
|
||||
</ows:AllowedValues>
|
||||
</LiteralData>
|
||||
</Input>
|
||||
<Input minOccurs="0" maxOccurs="1">
|
||||
<ows:Identifier>Outside_Polygons_Only</ows:Identifier><!-- 6 -->
|
||||
<ows:Title>Outside Polygons Only</ows:Title>
|
||||
<ows:Abstract>Valid only for input polygon features. FULL — Input polygon features will be given a complete buffer. This is the default. OUTSIDE_ONLY — The area inside the input polygon features will be excluded from the resulting buffer.</ows:Abstract>
|
||||
<LiteralData>
|
||||
<ows:DataType ows:reference="xs:boolean"></ows:DataType>
|
||||
<ows:AnyValue/>
|
||||
</LiteralData>
|
||||
</Input>
|
||||
</DataInputs>
|
||||
<ProcessOutputs>
|
||||
<Output>
|
||||
<ows:Identifier>Output_Feature_class</ows:Identifier><!-- 1 -->
|
||||
<ows:Title>Output Feature class</ows:Title>
|
||||
<ows:Abstract>The new polygon feature class to be created.</ows:Abstract>
|
||||
<ComplexOutput>
|
||||
<Default>
|
||||
<Format>
|
||||
<MimeType>application/x-zipped-shp</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Default>
|
||||
<Supported>
|
||||
<Format>
|
||||
<MimeType>application/x-zipped-shp</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
<Format>
|
||||
<MimeType>text/XML</MimeType>
|
||||
<Schema>http://schemas.opengis.net/gml/2.1.2/feature.xsd</Schema>
|
||||
</Format>
|
||||
</Supported>
|
||||
</ComplexOutput>
|
||||
</Output>
|
||||
</ProcessOutputs>
|
||||
</ProcessDescription>
|
||||
</wps:ProcessDescriptions>
|
||||
|
||||
|
||||
@ -1,103 +0,0 @@
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<wps:ProcessDescriptions xmlns:wps="http://www.opengis.net/wps/1.0.0" xmlns:ows="http://www.opengis.net/ows/1.1" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.opengis.net/wps/1.0.0
|
||||
http://schemas.opengis.net/wps/1.0.0/wpsDescribeProcess_response.xsd" xml:lang="en-US" service="WPS" version="1.0.0">
|
||||
<ProcessDescription wps:processVersion="2" statusSupported="true" storeSupported="true">
|
||||
<ows:Identifier>org.n52.wps.ags.analysis.proximity.near</ows:Identifier><!-- ParameterCount=5 -->
|
||||
<ows:Title>Near_analysis</ows:Title>
|
||||
<ows:Abstract>This determines the distance from each feature in the Input Features to the nearest features in the Near Features within the Search Radius. Uses ArcObjects library - Analysis</ows:Abstract>
|
||||
<DataInputs>
|
||||
<Input minOccurs="1" maxOccurs="1">
|
||||
<ows:Identifier>in_features</ows:Identifier><!-- 0 -->
|
||||
<ows:Title>in features</ows:Title>
|
||||
<ows:Abstract>The feature class or layer containing features from which distances are calculated to each feature in the Near Features.</ows:Abstract>
|
||||
<ComplexData>
|
||||
<Default>
|
||||
<Format>
|
||||
<MimeType>application/x-zipped-shp</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Default>
|
||||
<Supported>
|
||||
<Format>
|
||||
<MimeType>application/x-zipped-shp</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Supported>
|
||||
</ComplexData>
|
||||
</Input>
|
||||
<Input minOccurs="1" maxOccurs="1">
|
||||
<ows:Identifier>near_features</ows:Identifier><!-- 1 -->
|
||||
<ows:Title>near features</ows:Title>
|
||||
<ows:Abstract>The feature class or layer containing features from which distances are calculated to the closest feature in the Input Features. If multiple feature classes or layers are specified, an extra field named NEAR_FC will be added to the input feature class to identify which near feature class contains the closest feature.</ows:Abstract>
|
||||
<ComplexData>
|
||||
<Default>
|
||||
<Format>
|
||||
<MimeType>application/x-zipped-shp</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Default>
|
||||
<Supported>
|
||||
<Format>
|
||||
<MimeType>application/x-zipped-shp</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Supported>
|
||||
</ComplexData>
|
||||
</Input>
|
||||
<Input minOccurs="0" maxOccurs="1">
|
||||
<ows:Identifier>search_radius</ows:Identifier><!-- 2 -->
|
||||
<ows:Title>search radius</ows:Title>
|
||||
<ows:Abstract>The maximum distance between Input Features and Near Features for which distance and FID will be determined. If no Search Radius is specified, all Near Features will be used.</ows:Abstract>
|
||||
<LiteralData>
|
||||
<ows:DataType ows:reference="xs:string"></ows:DataType>
|
||||
<ows:AnyValue/>
|
||||
</LiteralData>
|
||||
</Input>
|
||||
<Input minOccurs="0" maxOccurs="1">
|
||||
<ows:Identifier>location</ows:Identifier><!-- 3 -->
|
||||
<ows:Title>location</ows:Title>
|
||||
<ows:Abstract>Determines whether the x,y coordinates of the nearest feature are added to the Input Features as well as NEAR_FID and NEAR_DIST. The new fields are NEAR_X and NEAR_Y. NO_LOCATION — The x,y coordinates or the nearest point are not saved. This is the default. LOCATION — Additional fields named NEAR_X and NEAR_Y will be added to the result. These fields will contain the x- and y-coordinates of the Near Features.</ows:Abstract>
|
||||
<LiteralData>
|
||||
<ows:DataType ows:reference="xs:boolean"></ows:DataType>
|
||||
<ows:AnyValue/>
|
||||
</LiteralData>
|
||||
</Input>
|
||||
<Input minOccurs="0" maxOccurs="1">
|
||||
<ows:Identifier>angle</ows:Identifier><!-- 4 -->
|
||||
<ows:Title>angle</ows:Title>
|
||||
<ows:Abstract>Determines whether the angle between the near feature will be calculated and stored in the NEAR_ANGLE field. The angle value is measured in degrees, where one degree represents 1/360 of a circle, and fractions of a degree are represented as decimal points. Angles are measured from 180° to -180° ; 0° to the east, 90° to the north, 180° (-180° ) to the west, and -90° to the south. NO_ANGLE — The angle between the nearest point will not be saved. This is the default. ANGLE — A field named NEAR_ANGLE will be added to the result and will contain the angle from the Input to the nearest point on the Near Feature.</ows:Abstract>
|
||||
<LiteralData>
|
||||
<ows:DataType ows:reference="xs:boolean"></ows:DataType>
|
||||
<ows:AnyValue/>
|
||||
</LiteralData>
|
||||
</Input>
|
||||
</DataInputs>
|
||||
<ProcessOutputs>
|
||||
<Output>
|
||||
<ows:Identifier>out_features</ows:Identifier><!-- 0 -->
|
||||
<ows:Title>modified input features</ows:Title>
|
||||
<ows:Abstract>The feature class or layer containing features from which distances are calculated to each feature in the Near Features.</ows:Abstract>
|
||||
<ComplexOutput>
|
||||
<Default>
|
||||
<Format>
|
||||
<MimeType>application/x-zipped-shp</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Default>
|
||||
<Supported>
|
||||
<Format>
|
||||
<MimeType>application/x-zipped-shp</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
<Format>
|
||||
<MimeType>text/XML</MimeType>
|
||||
<Schema>http://schemas.opengis.net/gml/2.1.2/feature.xsd</Schema>
|
||||
</Format>
|
||||
</Supported>
|
||||
</ComplexOutput>
|
||||
</Output>
|
||||
</ProcessOutputs>
|
||||
</ProcessDescription>
|
||||
</wps:ProcessDescriptions>
|
||||
|
||||
|
||||
@ -1,81 +0,0 @@
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<wps:ProcessDescriptions xmlns:wps="http://www.opengis.net/wps/1.0.0" xmlns:ows="http://www.opengis.net/ows/1.1" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.opengis.net/wps/1.0.0
|
||||
http://schemas.opengis.net/wps/1.0.0/wpsDescribeProcess_response.xsd" xml:lang="en-US" service="WPS" version="1.0.0">
|
||||
<ProcessDescription wps:processVersion="2" statusSupported="true" storeSupported="true">
|
||||
<ows:Identifier>org.n52.wps.ags.analysis.proximity.pointdistance</ows:Identifier><!-- ParameterCount=4 -->
|
||||
<ows:Title>PointDistance_analysis</ows:Title>
|
||||
<ows:Abstract>This determines the distances between point features in the Input Features to all points in the Near Features within the Search Radius. Uses ArcObjects library - Analysis</ows:Abstract>
|
||||
<DataInputs>
|
||||
<Input minOccurs="1" maxOccurs="1">
|
||||
<ows:Identifier>in_features</ows:Identifier><!-- 0 -->
|
||||
<ows:Title>in features</ows:Title>
|
||||
<ows:Abstract>The point features from which distances to the Near Features will be calculated.</ows:Abstract>
|
||||
<ComplexData>
|
||||
<Default>
|
||||
<Format>
|
||||
<MimeType>application/x-zipped-shp</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Default>
|
||||
<Supported>
|
||||
<Format>
|
||||
<MimeType>application/x-zipped-shp</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Supported>
|
||||
</ComplexData>
|
||||
</Input>
|
||||
<Input minOccurs="1" maxOccurs="1">
|
||||
<ows:Identifier>near_features</ows:Identifier><!-- 1 -->
|
||||
<ows:Title>near features</ows:Title>
|
||||
<ows:Abstract>The points to which distances from the Input Features will be determined. Distances between points within the same feature class or layer can be determined by specifying the same feature class or layer for the Input Features and Near Features.</ows:Abstract>
|
||||
<ComplexData>
|
||||
<Default>
|
||||
<Format>
|
||||
<MimeType>application/x-zipped-shp</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Default>
|
||||
<Supported>
|
||||
<Format>
|
||||
<MimeType>application/x-zipped-shp</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Supported>
|
||||
</ComplexData>
|
||||
</Input>
|
||||
<Input minOccurs="0" maxOccurs="1">
|
||||
<ows:Identifier>search_radius</ows:Identifier><!-- 3 -->
|
||||
<ows:Title>search radius</ows:Title>
|
||||
<ows:Abstract>Distances will only be calculated for those Near Features that are within the Search Radius of the Input Features.</ows:Abstract>
|
||||
<LiteralData>
|
||||
<ows:DataType ows:reference="xs:string"></ows:DataType>
|
||||
<ows:AnyValue/>
|
||||
</LiteralData>
|
||||
</Input>
|
||||
</DataInputs>
|
||||
<ProcessOutputs>
|
||||
<Output>
|
||||
<ows:Identifier>out_table</ows:Identifier><!-- 2 -->
|
||||
<ows:Title>out table</ows:Title>
|
||||
<ows:Abstract>The table contains the list of Input Features and information about all Near Features within the Search Radius. If Search Radius is not used, the number of records in the output table may be quite large, as it will be the number of features in the Input Features multiplied by the number of features in the Input Features.</ows:Abstract>
|
||||
<ComplexOutput>
|
||||
<Default>
|
||||
<Format>
|
||||
<MimeType>application/dbase</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Default>
|
||||
<Supported>
|
||||
<Format>
|
||||
<MimeType>application/dbase</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Supported>
|
||||
</ComplexOutput>
|
||||
</Output>
|
||||
</ProcessOutputs>
|
||||
</ProcessDescription>
|
||||
</wps:ProcessDescriptions>
|
||||
|
||||
|
||||
@ -1,71 +0,0 @@
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<wps:ProcessDescriptions xmlns:wps="http://www.opengis.net/wps/1.0.0" xmlns:ows="http://www.opengis.net/ows/1.1" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.opengis.net/wps/1.0.0
|
||||
http://schemas.opengis.net/wps/1.0.0/wpsDescribeProcess_response.xsd" xml:lang="en-US" service="WPS" version="1.0.0">
|
||||
<ProcessDescription wps:processVersion="2" statusSupported="true" storeSupported="true">
|
||||
<ows:Identifier>org.n52.wps.ags.analysis.statistics.frequency</ows:Identifier><!-- ParameterCount=4 -->
|
||||
<ows:Title>Frequency_analysis</ows:Title>
|
||||
<ows:Abstract>This creates a list of the unique code occurrences and their frequency for a specified set of items in a table. Uses ArcObjects library - Analysis</ows:Abstract>
|
||||
<DataInputs>
|
||||
<Input minOccurs="1" maxOccurs="1">
|
||||
<ows:Identifier>in_table</ows:Identifier><!-- 0 -->
|
||||
<ows:Title>in table</ows:Title>
|
||||
<ows:Abstract>The table containing the field(s) that will be used to calculate frequency statistics. It can be an INFO or OLE DB table, a dBASE or a VPF table, or a feature class.</ows:Abstract>
|
||||
<ComplexData>
|
||||
<Default>
|
||||
<Format>
|
||||
<MimeType>application/dbf</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Default>
|
||||
<Supported>
|
||||
<Format>
|
||||
<MimeType>application/dbf</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Supported>
|
||||
</ComplexData>
|
||||
</Input>
|
||||
<Input minOccurs="1" maxOccurs="1">
|
||||
<ows:Identifier>frequency_fields</ows:Identifier><!-- 2 -->
|
||||
<ows:Title>frequency fields</ows:Title>
|
||||
<ows:Abstract>The attribute field or fields that will be used to calculate frequency statistics.</ows:Abstract>
|
||||
<LiteralData>
|
||||
<ows:DataType ows:reference="xs:string"></ows:DataType>
|
||||
<ows:AnyValue/>
|
||||
</LiteralData>
|
||||
</Input>
|
||||
<Input minOccurs="0" maxOccurs="1">
|
||||
<ows:Identifier>summary_fields</ows:Identifier><!-- 3 -->
|
||||
<ows:Title>summary fields</ows:Title>
|
||||
<ows:Abstract>The attribute field or fields to sum and add to the output table. Null values are excluded from this calculation.</ows:Abstract>
|
||||
<LiteralData>
|
||||
<ows:DataType ows:reference="xs:string"></ows:DataType>
|
||||
<ows:AnyValue/>
|
||||
</LiteralData>
|
||||
</Input>
|
||||
</DataInputs>
|
||||
<ProcessOutputs>
|
||||
<Output>
|
||||
<ows:Identifier>out_table</ows:Identifier><!-- 1 -->
|
||||
<ows:Title>out table</ows:Title>
|
||||
<ows:Abstract>The table that will store the calculated frequency statistics.</ows:Abstract>
|
||||
<ComplexOutput>
|
||||
<Default>
|
||||
<Format>
|
||||
<MimeType>application/dbf</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Default>
|
||||
<Supported>
|
||||
<Format>
|
||||
<MimeType>application/dbf</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Supported>
|
||||
</ComplexOutput>
|
||||
</Output>
|
||||
</ProcessOutputs>
|
||||
</ProcessDescription>
|
||||
</wps:ProcessDescriptions>
|
||||
|
||||
|
||||
@ -1,100 +0,0 @@
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<wps:ProcessDescriptions xmlns:wps="http://www.opengis.net/wps/1.0.0" xmlns:ows="http://www.opengis.net/ows/1.1" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.opengis.net/wps/1.0.0
|
||||
http://schemas.opengis.net/wps/1.0.0/wpsDescribeProcess_response.xsd" xml:lang="en-US" service="WPS" version="1.0.0">
|
||||
<ProcessDescription wps:processVersion="2" statusSupported="true" storeSupported="true">
|
||||
<ows:Identifier>org.n52.wps.ags.spatialanalyst.density.linedensity</ows:Identifier><!-- ParameterCount=6 -->
|
||||
<ows:Title>LineDensity_sa</ows:Title>
|
||||
<ows:Abstract>Calculates a magnitude per unit area from polyline features that fall within a radius around each cell. Uses ArcObjects library - Spatial Analyst</ows:Abstract>
|
||||
<DataInputs>
|
||||
<Input minOccurs="1" maxOccurs="1">
|
||||
<ows:Identifier>input features</ows:Identifier><!-- 0 -->
|
||||
<ows:Title>input polyline features</ows:Title>
|
||||
<ows:Abstract>the input polyline feature to calculate the density for</ows:Abstract>
|
||||
<ComplexData>
|
||||
<Default>
|
||||
<Format>
|
||||
<MimeType>application/x-zipped-shp</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Default>
|
||||
<Supported>
|
||||
<Format>
|
||||
<MimeType>application/x-zipped-shp</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Supported>
|
||||
</ComplexData>
|
||||
</Input>
|
||||
<Input minOccurs="1" maxOccurs="1">
|
||||
<ows:Identifier>field</ows:Identifier><!-- 1 -->
|
||||
<ows:Title>population field as string</ows:Title>
|
||||
<ows:Abstract>Field denoting population values for each feature. the population field is the count or quantity to be spread across the landscape to create continuous surface. values may be integer or floating point. a valid field name of the input features is required.</ows:Abstract>
|
||||
<LiteralData>
|
||||
<ows:DataType ows:reference="xs:string"></ows:DataType>
|
||||
<ows:AnyValue/>
|
||||
</LiteralData>
|
||||
</Input>
|
||||
<Input minOccurs="0" maxOccurs="1">
|
||||
<ows:Identifier>cell size</ows:Identifier><!-- 3 -->
|
||||
<ows:Title>output cell size</ows:Title>
|
||||
<ows:Abstract>The cell size at which the output raster will be created. If the environment is not set, then cell size is the shorter of the width or height of the extent of input point or polyline features in the output spatial reference, divided by 250.</ows:Abstract>
|
||||
<LiteralData>
|
||||
<ows:DataType ows:reference="xs:double"></ows:DataType>
|
||||
<ows:AnyValue/>
|
||||
</LiteralData>
|
||||
</Input>
|
||||
<Input minOccurs="0" maxOccurs="1">
|
||||
<ows:Identifier>radius</ows:Identifier><!-- 4 -->
|
||||
<ows:Title>search radius</ows:Title>
|
||||
<ows:Abstract>The search radius within which to calculate density. Units are based on the linear unit of the projection of the output spatial reference. The default is the shortest of the width or height of the extent of in_features in the output spatial reference, divided by 30.</ows:Abstract>
|
||||
<LiteralData>
|
||||
<ows:DataType ows:reference="xs:double"></ows:DataType>
|
||||
<ows:AnyValue/>
|
||||
</LiteralData>
|
||||
</Input>
|
||||
<Input minOccurs="0" maxOccurs="1">
|
||||
<ows:Identifier>units</ows:Identifier><!-- 5 -->
|
||||
<ows:Title>area units</ows:Title>
|
||||
<ows:Abstract>The desired area units of the output density values. the value can be "SQUARE_MAP_UNITS", "SQUARE_MILES", "SQUARE_KILOMETERS","SQUARE_INCHES", "SQUARE_CENTIMETERS" or "SQUARE_MILLIMETERS". A default unit is selected based on the linear unit of the projection of the output spatial reference.</ows:Abstract>
|
||||
<LiteralData>
|
||||
<ows:DataType ows:reference="xs:string"></ows:DataType>
|
||||
<ows:AllowedValues>
|
||||
<ows:Value>SQUARE_MAP_UNITS</ows:Value>
|
||||
<ows:Value>SQUARE_MILES</ows:Value>
|
||||
<ows:Value>SQUARE_KILOMETERS</ows:Value>
|
||||
<ows:Value>SQUARE_INCHES</ows:Value>
|
||||
<ows:Value>SQUARE_CENTIMETERS</ows:Value>
|
||||
<ows:Value>SQUARE_MILLIMETERS</ows:Value>
|
||||
</ows:AllowedValues>
|
||||
</LiteralData>
|
||||
</Input>
|
||||
</DataInputs>
|
||||
<ProcessOutputs>
|
||||
<Output>
|
||||
<ows:Identifier>result</ows:Identifier><!-- 2 -->
|
||||
<ows:Title>raster values</ows:Title>
|
||||
<ows:Abstract>result raster</ows:Abstract>
|
||||
<ComplexOutput>
|
||||
<Default>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Default>
|
||||
<Supported>
|
||||
<Format>
|
||||
<MimeType>application/GeoTIFF</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Supported>
|
||||
</ComplexOutput>
|
||||
</Output>
|
||||
</ProcessOutputs>
|
||||
</ProcessDescription>
|
||||
</wps:ProcessDescriptions>
|
||||
|
||||
|
||||
@ -1,84 +0,0 @@
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<wps:ProcessDescriptions xmlns:wps="http://www.opengis.net/wps/1.0.0" xmlns:ows="http://www.opengis.net/ows/1.1" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.opengis.net/wps/1.0.0
|
||||
http://schemas.opengis.net/wps/1.0.0/wpsDescribeProcess_response.xsd" xml:lang="en-US" service="WPS" version="1.0.0">
|
||||
<ProcessDescription wps:processVersion="2" statusSupported="true" storeSupported="true">
|
||||
<ows:Identifier>org.n52.wps.ags.spatialanalyst.distance.corridor</ows:Identifier><!-- ParameterCount=3 -->
|
||||
<ows:Title>Corridor_sa</ows:Title>
|
||||
<ows:Abstract>Calculates the sum of accumulative costs for two input accumulative cost raster. Uses ArcObjects library - Spatial Analyst</ows:Abstract>
|
||||
<DataInputs>
|
||||
<Input minOccurs="1" maxOccurs="1">
|
||||
<ows:Identifier>in_distance_raster1</ows:Identifier><!-- 0 -->
|
||||
<ows:Title>in distance raster1</ows:Title>
|
||||
<ows:Abstract>An input raster that was the output accumulated cost raster from a global cost function.</ows:Abstract>
|
||||
<ComplexData>
|
||||
<Default>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Default>
|
||||
<Supported>
|
||||
<Format>
|
||||
<MimeType>application/GeoTIFF</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Supported>
|
||||
</ComplexData>
|
||||
</Input>
|
||||
<Input minOccurs="1" maxOccurs="1">
|
||||
<ows:Identifier>in_distance_raster2</ows:Identifier><!-- 1 -->
|
||||
<ows:Title>in distance raster2</ows:Title>
|
||||
<ows:Abstract>An input raster that was the output accumulated cost raster from a global cost function.</ows:Abstract>
|
||||
<ComplexData>
|
||||
<Default>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Default>
|
||||
<Supported>
|
||||
<Format>
|
||||
<MimeType>application/GeoTIFF</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Supported>
|
||||
</ComplexData>
|
||||
</Input>
|
||||
</DataInputs>
|
||||
<ProcessOutputs>
|
||||
<Output>
|
||||
<ows:Identifier>out_raster</ows:Identifier><!-- 2 -->
|
||||
<ows:Title>out raster</ows:Title>
|
||||
<ows:Abstract>The raster to be created.</ows:Abstract>
|
||||
<ComplexOutput>
|
||||
<Default>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Default>
|
||||
<Supported>
|
||||
<Format>
|
||||
<MimeType>application/GeoTIFF</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Supported>
|
||||
</ComplexOutput>
|
||||
</Output>
|
||||
</ProcessOutputs>
|
||||
</ProcessDescription>
|
||||
</wps:ProcessDescriptions>
|
||||
|
||||
|
||||
@ -1,175 +0,0 @@
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<wps:ProcessDescriptions xmlns:wps="http://www.opengis.net/wps/1.0.0" xmlns:ows="http://www.opengis.net/ows/1.1" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.opengis.net/wps/1.0.0
|
||||
http://schemas.opengis.net/wps/1.0.0/wpsDescribeProcess_response.xsd" xml:lang="en-US" service="WPS" version="1.0.0">
|
||||
<ProcessDescription wps:processVersion="2" statusSupported="true" storeSupported="true">
|
||||
<ows:Identifier>org.n52.wps.ags.spatialanalyst.distance.costallocation</ows:Identifier><!-- ParameterCount=8 -->
|
||||
<ows:Title>CostAllocation_sa</ows:Title>
|
||||
<ows:Abstract>Calculates, for each cell its nearest source based on the least accumulative cost over a cost surface. Uses ArcObjects library - Spatial Analyst</ows:Abstract>
|
||||
<DataInputs>
|
||||
<Input minOccurs="1" maxOccurs="1">
|
||||
<ows:Identifier>in_source_data</ows:Identifier><!-- 0 -->
|
||||
<ows:Title>in source data</ows:Title>
|
||||
<ows:Abstract>The input source locations. This is a raster or feature dataset that identifies the cells or locations to which the least accumulated cost distances for all cells are calculated. If raster, it must be integer type. For features, only integer fields can be used.</ows:Abstract>
|
||||
<ComplexData>
|
||||
<Default>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Default>
|
||||
<Supported>
|
||||
<Format>
|
||||
<MimeType>application/GeoTIFF</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
<Format>
|
||||
<MimeType>application/x-zipped-shape</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Supported>
|
||||
</ComplexData>
|
||||
</Input>
|
||||
<Input minOccurs="1" maxOccurs="1">
|
||||
<ows:Identifier>in_cost_raster</ows:Identifier><!-- 1 -->
|
||||
<ows:Title>in cost raster</ows:Title>
|
||||
<ows:Abstract>A raster defining the impedance or cost to move planimetrically through each cell. The value at each cell location represents the cost per unit distance for moving through the cell. Each cell location value is multiplied by the cell resolution while also compensating for diagonal movement to obtain the total cost of passing through the cell. The in_cost_raster values can be integer or floating point, but they cannot be negative or zero (you cannot have a negative or zero cost).</ows:Abstract>
|
||||
<ComplexData>
|
||||
<Default>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Default>
|
||||
<Supported>
|
||||
<Format>
|
||||
<MimeType>application/GeoTIFF</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Supported>
|
||||
</ComplexData>
|
||||
</Input>
|
||||
<Input minOccurs="0" maxOccurs="1">
|
||||
<ows:Identifier>source_field</ows:Identifier><!-- 5 -->
|
||||
<ows:Title>source field</ows:Title>
|
||||
<ows:Abstract>The field used to assign values to the source locations when the {in_value_raster} is not set. The value raster will take precedence over any setting for the {source_field}.</ows:Abstract>
|
||||
<LiteralData>
|
||||
<ows:DataType ows:reference="xs:string"></ows:DataType>
|
||||
<ows:AnyValue/>
|
||||
</LiteralData>
|
||||
</Input>
|
||||
<Input minOccurs="0" maxOccurs="1">
|
||||
<ows:Identifier>in_value_raster</ows:Identifier><!-- 4 -->
|
||||
<ows:Title>in value raster</ows:Title>
|
||||
<ows:Abstract>An optional input raster that identifies the zone values that should be used for each source location on the in_source_data. For each source location (cell or feature), the value defined by the {in_value_raster} will be assigned to all cells that will be allocated to the source location in the cost allocation computations. The value raster will take precedence over any setting for the {source_field}. This parameter can be used if other values or zones are to be used instead of the existing ones in the input source. This parameter can also be used if the source raster was created by the Test function, a Boolean operator that will only output the binary values 0 and 1.</ows:Abstract>
|
||||
<ComplexData>
|
||||
<Default>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Default>
|
||||
<Supported>
|
||||
<Format>
|
||||
<MimeType>application/GeoTIFF</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Supported>
|
||||
</ComplexData>
|
||||
</Input>
|
||||
<Input minOccurs="0" maxOccurs="1">
|
||||
<ows:Identifier>maximum_distance</ows:Identifier><!-- 3 -->
|
||||
<ows:Title>maximum distance</ows:Title>
|
||||
<ows:Abstract>Defines the threshold that the accumulative cost values cannot exceed. If an accumulative cost distance value exceeds the {max_distance}, the output value for the cell location will be NoData. The {max_distance} defines the extent for which the accumulative cost distances are calculated. The default distance is to the edge of the output raster.</ows:Abstract>
|
||||
<LiteralData>
|
||||
<ows:DataType ows:reference="xs:integer"></ows:DataType>
|
||||
<ows:AnyValue/>
|
||||
</LiteralData>
|
||||
</Input>
|
||||
</DataInputs>
|
||||
<ProcessOutputs>
|
||||
<Output>
|
||||
<ows:Identifier>out_allocation_raster</ows:Identifier><!-- 2 -->
|
||||
<ows:Title>out allocation raster</ows:Title>
|
||||
<ows:Abstract>A raster that identifies the zone of each source location (cell or feature) that could be reached with the least accumulative cost.</ows:Abstract>
|
||||
<ComplexOutput>
|
||||
<Default>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Default>
|
||||
<Supported>
|
||||
<Format>
|
||||
<MimeType>application/GeoTIFF</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Supported>
|
||||
</ComplexOutput>
|
||||
</Output>
|
||||
<Output>
|
||||
<ows:Identifier>out_distance_raster</ows:Identifier><!-- 6 -->
|
||||
<ows:Title>out distance raster</ows:Title>
|
||||
<ows:Abstract>A raster that identifies the zone of each source location (cell or feature) that could be reached with the least accumulative cost.</ows:Abstract>
|
||||
<ComplexOutput>
|
||||
<Default>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Default>
|
||||
<Supported>
|
||||
<Format>
|
||||
<MimeType>application/GeoTIFF</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Supported>
|
||||
</ComplexOutput>
|
||||
</Output>
|
||||
<Output>
|
||||
<ows:Identifier>out_backlink_raster</ows:Identifier><!-- 7 -->
|
||||
<ows:Title>out backlink raster</ows:Title>
|
||||
<ows:Abstract>The name of the output cost back link raster. The back link raster contains values of 0 through 8, which define the direction or identify the next neighboring cell (the succeeding cell) along the least accumulative cost path from a cell to reach its least cost source. If the path is to pass into the right neighbor, the cell will be assigned the value 1, 2 for the lower right diagonal cell, and continuing clockwise. The value 0 is reserved for source cells.</ows:Abstract>
|
||||
<ComplexOutput>
|
||||
<Default>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Default>
|
||||
<Supported>
|
||||
<Format>
|
||||
<MimeType>application/GeoTIFF</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Supported>
|
||||
</ComplexOutput>
|
||||
</Output>
|
||||
</ProcessOutputs>
|
||||
</ProcessDescription>
|
||||
</wps:ProcessDescriptions>
|
||||
|
||||
|
||||
@ -1,120 +0,0 @@
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<wps:ProcessDescriptions xmlns:wps="http://www.opengis.net/wps/1.0.0" xmlns:ows="http://www.opengis.net/ows/1.1" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.opengis.net/wps/1.0.0
|
||||
http://schemas.opengis.net/wps/1.0.0/wpsDescribeProcess_response.xsd" xml:lang="en-US" service="WPS" version="1.0.0">
|
||||
<ProcessDescription wps:processVersion="2" statusSupported="true" storeSupported="true">
|
||||
<ows:Identifier>org.n52.wps.ags.spatialanalyst.distance.costbacklink</ows:Identifier><!-- ParameterCount=5 -->
|
||||
<ows:Title>CostBackLink_sa</ows:Title>
|
||||
<ows:Abstract>Defines the neighbor that is the next cell on the least accumulative cost path to the nearest source. Uses ArcObjects library - Spatial Analyst</ows:Abstract>
|
||||
<DataInputs>
|
||||
<Input minOccurs="1" maxOccurs="1">
|
||||
<ows:Identifier>in_source_data</ows:Identifier><!-- 0 -->
|
||||
<ows:Title>in source data</ows:Title>
|
||||
<ows:Abstract>The input source locations. This is a raster or feature dataset that identifies the cells or locations to which the least accumulated cost distance for every cell is calculated. For rasters, it must be of integer type. For features, only integer fields can be used.</ows:Abstract>
|
||||
<ComplexData>
|
||||
<Default>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Default>
|
||||
<Supported>
|
||||
<Format>
|
||||
<MimeType>application/GeoTIFF</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
<Format>
|
||||
<MimeType>application/x-zipped-shape</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Supported>
|
||||
</ComplexData>
|
||||
</Input>
|
||||
<Input minOccurs="1" maxOccurs="1">
|
||||
<ows:Identifier>in_cost_raster</ows:Identifier><!-- 1 -->
|
||||
<ows:Title>in cost raster</ows:Title>
|
||||
<ows:Abstract>A raster defining the impedance or cost to move planimetrically through each cell. The value at each cell location represents the cost per unit distance for moving through the cell. Each cell location value is multiplied by the cell resolution, while compensating for diagonal movement, to obtain the total cost of passing through the cell. The values on the in_cost_raster can be integer or floating point, but they cannot be negative or zero (you cannot have a negative or zero cost).</ows:Abstract>
|
||||
<ComplexData>
|
||||
<Default>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Default>
|
||||
<Supported>
|
||||
<Format>
|
||||
<MimeType>application/GeoTIFF</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Supported>
|
||||
</ComplexData>
|
||||
</Input>
|
||||
<Input minOccurs="0" maxOccurs="1">
|
||||
<ows:Identifier>maximum_distance</ows:Identifier><!-- 3 -->
|
||||
<ows:Title>maximum distance</ows:Title>
|
||||
<ows:Abstract>Defines the threshold that the accumulative cost values cannot exceed. If an accumulative cost distance value exceeds the {max_distance}, the output value for the cell location will be NoData. The {max_distance} defines the extent for which the accumulative cost distances are calculated. The default distance is to the edge of the output raster.</ows:Abstract>
|
||||
<LiteralData>
|
||||
<ows:DataType ows:reference="xs:double"></ows:DataType>
|
||||
<ows:AnyValue/>
|
||||
</LiteralData>
|
||||
</Input>
|
||||
</DataInputs>
|
||||
<ProcessOutputs>
|
||||
<Output>
|
||||
<ows:Identifier>out_backlink_raster</ows:Identifier><!-- 2 -->
|
||||
<ows:Title>out backlink raster</ows:Title>
|
||||
<ows:Abstract>output backlink raster</ows:Abstract>
|
||||
<ComplexOutput>
|
||||
<Default>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Default>
|
||||
<Supported>
|
||||
<Format>
|
||||
<MimeType>application/GeoTIFF</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Supported>
|
||||
</ComplexOutput>
|
||||
</Output>
|
||||
<Output>
|
||||
<ows:Identifier>out_distance_raster</ows:Identifier><!-- 4 -->
|
||||
<ows:Title>out distance raster</ows:Title>
|
||||
<ows:Abstract>The name of the output cost distance raster. The cost distance raster identifies, for each cell, the least accumulative cost distance over a cost surface to the identified source locations. A source can be a cell, a set of cells, or feature locations.</ows:Abstract>
|
||||
<ComplexOutput>
|
||||
<Default>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Default>
|
||||
<Supported>
|
||||
<Format>
|
||||
<MimeType>application/GeoTIFF</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Supported>
|
||||
</ComplexOutput>
|
||||
</Output>
|
||||
</ProcessOutputs>
|
||||
</ProcessDescription>
|
||||
</wps:ProcessDescriptions>
|
||||
|
||||
|
||||
@ -1,120 +0,0 @@
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<wps:ProcessDescriptions xmlns:wps="http://www.opengis.net/wps/1.0.0" xmlns:ows="http://www.opengis.net/ows/1.1" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.opengis.net/wps/1.0.0
|
||||
http://schemas.opengis.net/wps/1.0.0/wpsDescribeProcess_response.xsd" xml:lang="en-US" service="WPS" version="1.0.0">
|
||||
<ProcessDescription wps:processVersion="2" statusSupported="true" storeSupported="true">
|
||||
<ows:Identifier>org.n52.wps.ags.spatialanalyst.distance.costdistance</ows:Identifier><!-- ParameterCount=5 -->
|
||||
<ows:Title>CostDistance_sa</ows:Title>
|
||||
<ows:Abstract>Calculates the least accumulative cost distance for each cell to the nearest source over a cost surface. Uses ArcObjects library - Spatial Analyst</ows:Abstract>
|
||||
<DataInputs>
|
||||
<Input minOccurs="1" maxOccurs="1">
|
||||
<ows:Identifier>in_source_data</ows:Identifier><!-- 0 -->
|
||||
<ows:Title>in source data</ows:Title>
|
||||
<ows:Abstract>The input source locations. A raster or feature dataset that identifies the cells or locations to which the least accumulated cost distance for every cell is calculated. For rasters, the input value can be integer, string, or floating-point type if in_value_raster is used.</ows:Abstract>
|
||||
<ComplexData>
|
||||
<Default>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Default>
|
||||
<Supported>
|
||||
<Format>
|
||||
<MimeType>application/GeoTIFF</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
<Format>
|
||||
<MimeType>application/x-zipped-shape</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Supported>
|
||||
</ComplexData>
|
||||
</Input>
|
||||
<Input minOccurs="1" maxOccurs="1">
|
||||
<ows:Identifier>in_cost_raster</ows:Identifier><!-- 1 -->
|
||||
<ows:Title>in cost raster</ows:Title>
|
||||
<ows:Abstract>A raster defining the impedance or cost to move planimetrically through each cell. The value at each cell location represents the cost per unit distance for moving through the cell. Each cell location value is multiplied by the cell resolution, while compensating for diagonal movement, to obtain the total cost of passing through the cell. The values on the in_cost_raster can be integer or floating point, but they cannot be negative or zero (you cannot have a negative or zero cost).</ows:Abstract>
|
||||
<ComplexData>
|
||||
<Default>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Default>
|
||||
<Supported>
|
||||
<Format>
|
||||
<MimeType>application/GeoTIFF</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Supported>
|
||||
</ComplexData>
|
||||
</Input>
|
||||
<Input minOccurs="0" maxOccurs="1">
|
||||
<ows:Identifier>maximum_distance</ows:Identifier><!-- 3 -->
|
||||
<ows:Title>maximum distance</ows:Title>
|
||||
<ows:Abstract>Defines the threshold that the accumulative cost values cannot exceed. If an accumulative cost distance value exceeds the {max_distance}, the output value for the cell location will be NoData. The {max_distance} defines the extent for which the accumulative cost distances are calculated. The default distance is to the edge of the output raster.</ows:Abstract>
|
||||
<LiteralData>
|
||||
<ows:DataType ows:reference="xs:integer"></ows:DataType>
|
||||
<ows:AnyValue/>
|
||||
</LiteralData>
|
||||
</Input>
|
||||
</DataInputs>
|
||||
<ProcessOutputs>
|
||||
<Output>
|
||||
<ows:Identifier>out_distance_raster</ows:Identifier><!-- 2 -->
|
||||
<ows:Title>out distance raster</ows:Title>
|
||||
<ows:Abstract>The name of the output cost distance raster. The cost distance raster identifies, for each cell, the least accumulative cost distance over a cost surface to the identified source locations. A source can be a cell, a set of cells, or one or more feature locations.</ows:Abstract>
|
||||
<ComplexOutput>
|
||||
<Default>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Default>
|
||||
<Supported>
|
||||
<Format>
|
||||
<MimeType>application/GeoTIFF</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Supported>
|
||||
</ComplexOutput>
|
||||
</Output>
|
||||
<Output>
|
||||
<ows:Identifier>out_backlink_raster</ows:Identifier><!-- 4 -->
|
||||
<ows:Title>out backlink raster</ows:Title>
|
||||
<ows:Abstract>The name of the output cost backlink raster. The backlink raster contains values of 0 through 8, which define the direction or identify the next neighboring cell (the succeeding cell) along the least accumulative cost path from a cell to reach its least cost source. If the path is to pass into the right neighbor, the cell will be assigned the value 1, 2 for the lower right diagonal cell, and continuing clockwise. The value 0 is reserved for source cells.</ows:Abstract>
|
||||
<ComplexOutput>
|
||||
<Default>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Default>
|
||||
<Supported>
|
||||
<Format>
|
||||
<MimeType>application/GeoTIFF</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Supported>
|
||||
</ComplexOutput>
|
||||
</Output>
|
||||
</ProcessOutputs>
|
||||
</ProcessDescription>
|
||||
</wps:ProcessDescriptions>
|
||||
|
||||
|
||||
@ -1,126 +0,0 @@
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<wps:ProcessDescriptions xmlns:wps="http://www.opengis.net/wps/1.0.0" xmlns:ows="http://www.opengis.net/ows/1.1" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.opengis.net/wps/1.0.0
|
||||
http://schemas.opengis.net/wps/1.0.0/wpsDescribeProcess_response.xsd" xml:lang="en-US" service="WPS" version="1.0.0">
|
||||
<ProcessDescription wps:processVersion="2" statusSupported="true" storeSupported="true">
|
||||
<ows:Identifier>org.n52.wps.ags.spatialanalyst.distance.costpath</ows:Identifier><!-- ParameterCount=6 -->
|
||||
<ows:Title>CostPath_sa</ows:Title>
|
||||
<ows:Abstract>Calculates the least-cost path from a source to a destination. Uses ArcObjects library - Spatial Analyst</ows:Abstract>
|
||||
<DataInputs>
|
||||
<Input minOccurs="1" maxOccurs="1">
|
||||
<ows:Identifier>in_destination_data</ows:Identifier><!-- 0 -->
|
||||
<ows:Title>in destination data</ows:Title>
|
||||
<ows:Abstract>A raster or feature dataset that identifies those cells from which the least-cost path is determined to the least costly source. If the input is a raster, the input consists of cells that have valid values (zero is a valid value), and the remaining cells must be assigned NoData.</ows:Abstract>
|
||||
<ComplexData>
|
||||
<Default>
|
||||
<Format>
|
||||
<MimeType>application/x-zipped-shape</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Default>
|
||||
<Supported>
|
||||
<Format>
|
||||
<MimeType>application/x-zipped-shape</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Supported>
|
||||
</ComplexData>
|
||||
</Input>
|
||||
<Input minOccurs="0" maxOccurs="1">
|
||||
<ows:Identifier>destination_field</ows:Identifier><!-- 5 -->
|
||||
<ows:Title>destination field</ows:Title>
|
||||
<ows:Abstract>The field used to obtain values for the destination locations. Input feature data must contain at least one valid field.</ows:Abstract>
|
||||
<LiteralData>
|
||||
<ows:DataType ows:reference="xs:string"></ows:DataType>
|
||||
<ows:AnyValue/>
|
||||
</LiteralData>
|
||||
</Input>
|
||||
<Input minOccurs="1" maxOccurs="1">
|
||||
<ows:Identifier>in_cost_distance_raster</ows:Identifier><!-- 1 -->
|
||||
<ows:Title>in cost distance raster</ows:Title>
|
||||
<ows:Abstract>The name of a cost distance raster used to determine the least-cost path from the in_destination_data cell locations to a source. The in_cost_distance_raster is usually created with the CostDistance function (or by the CostAllocation or CostBackLink functions). The in_cost_distance_raster stores, for each cell, the minimum accumulative cost distance over a cost surface from each cell to a set of source cells.</ows:Abstract>
|
||||
<ComplexData>
|
||||
<Default>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Default>
|
||||
<Supported>
|
||||
<Format>
|
||||
<MimeType>application/GeoTIFF</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Supported>
|
||||
</ComplexData>
|
||||
</Input>
|
||||
<Input minOccurs="1" maxOccurs="1">
|
||||
<ows:Identifier>in cost backlink raster</ows:Identifier><!-- 2 -->
|
||||
<ows:Title>in cost backlink raster</ows:Title>
|
||||
<ows:Abstract>The name of a cost backlink raster used to determine the path to return to a source via the least-cost path. For each cell in the backlink raster, a value identifies the neighbor that is the next cell on the least accumulative cost path from the cell to a single source cell or set of source cells.</ows:Abstract>
|
||||
<ComplexData>
|
||||
<Default>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Default>
|
||||
<Supported>
|
||||
<Format>
|
||||
<MimeType>application/GeoTIFF</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Supported>
|
||||
</ComplexData>
|
||||
</Input>
|
||||
<Input minOccurs="0" maxOccurs="1">
|
||||
<ows:Identifier>path_type</ows:Identifier><!-- 4 -->
|
||||
<ows:Title>path type</ows:Title>
|
||||
<ows:Abstract>A keyword defining the manner in which the values and zones on the in_destination_data will be interpreted in the cost path calculations. EACH_CELL — For each cell with valid values on the in_destination_data, a least-cost path is determined and saved on the output raster of the CostPath function. With EACH_CELL, each cell of the in_destination_data input is treated separately, and a least-cost path is determined for each from cell. EACH_ZONE — For each zone on the in_destination_data , a least-cost path is determined and saved on the output raster of the CostPath function. With the EACH_ZONE keyword, the least-cost path for each zone begins at the cell with the lowest cost distance weighting in the zone. BEST_SINGLE — For all cells on the in_destination_data input, the least-cost path is derived from the cell with the minimum of the least-cost paths to source cells.
|
||||
</ows:Abstract>
|
||||
<LiteralData>
|
||||
<ows:DataType ows:reference="xs:string"></ows:DataType>
|
||||
<ows:AllowedValues>
|
||||
<ows:Value>EACH_CELL</ows:Value>
|
||||
<ows:Value>EACH_ZONE</ows:Value>
|
||||
<ows:Value>BEST_SINGLE</ows:Value>
|
||||
</ows:AllowedValues>
|
||||
</LiteralData>
|
||||
</Input>
|
||||
</DataInputs>
|
||||
<ProcessOutputs>
|
||||
<Output>
|
||||
<ows:Identifier>out_raster</ows:Identifier><!-- 3 -->
|
||||
<ows:Title>out raster</ows:Title>
|
||||
<ows:Abstract>The raster to be created.</ows:Abstract>
|
||||
<ComplexOutput>
|
||||
<Default>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Default>
|
||||
<Supported>
|
||||
<Format>
|
||||
<MimeType>application/GeoTIFF</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Supported>
|
||||
</ComplexOutput>
|
||||
</Output>
|
||||
</ProcessOutputs>
|
||||
</ProcessDescription>
|
||||
</wps:ProcessDescriptions>
|
||||
|
||||
|
||||
@ -1,161 +0,0 @@
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<wps:ProcessDescriptions xmlns:wps="http://www.opengis.net/wps/1.0.0" xmlns:ows="http://www.opengis.net/ows/1.1" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.opengis.net/wps/1.0.0
|
||||
http://schemas.opengis.net/wps/1.0.0/wpsDescribeProcess_response.xsd" xml:lang="en-US" service="WPS" version="1.0.0">
|
||||
<ProcessDescription wps:processVersion="2" statusSupported="true" storeSupported="true">
|
||||
<ows:Identifier>org.n52.wps.ags.spatialanalyst.distance.euclideanallocation</ows:Identifier><!-- ParameterCount=8 -->
|
||||
<ows:Title>EuclideanAllocation_sa</ows:Title>
|
||||
<ows:Abstract>Calculates, for each cell, the nearest source based on Euclidean distance. Uses ArcObjects library - Spatial Analyst</ows:Abstract>
|
||||
<DataInputs>
|
||||
<Input minOccurs="1" maxOccurs="1">
|
||||
<ows:Identifier>in_source_data</ows:Identifier><!-- 0 -->
|
||||
<ows:Title>in source data</ows:Title>
|
||||
<ows:Abstract>The input source locations. A raster or feature dataset in which the zone of closest cells is determined for each defined location. The value of each location in the input source dataset is assigned to its respective zone in the output raster. For rasters, the input can be integer or floating point. If the input is floating point, a value raster must be set. The value raster must be integer. The value raster will take precedence over the source field if it is set.</ows:Abstract>
|
||||
<ComplexData>
|
||||
<Default>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Default>
|
||||
<Supported>
|
||||
<Format>
|
||||
<MimeType>application/GeoTIFF</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
<Format>
|
||||
<MimeType>application/x-zipped-shape</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Supported>
|
||||
</ComplexData>
|
||||
</Input>
|
||||
<Input minOccurs="0" maxOccurs="1">
|
||||
<ows:Identifier>in_value_raster</ows:Identifier><!-- 3 -->
|
||||
<ows:Title>in value raster</ows:Title>
|
||||
<ows:Abstract>An optional integer input raster that identifies the zone values that should be used for each source location on the in_source_data. For each source location (cell or feature), the value defined by the {in_value_raster} will be assigned to all cells allocated to the source location in the cost allocation computations. The value raster will take precedence over any setting for the {source_field}. This parameter can be used if other values or zones are used instead of those existing in the input source. This parameter must be used if the source field is floating point. This parameter can also be used if the source raster was created by the Test function, a Boolean operator that will only output the binary values zero and one.</ows:Abstract>
|
||||
<ComplexData>
|
||||
<Default>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Default>
|
||||
<Supported>
|
||||
<Format>
|
||||
<MimeType>application/GeoTIFF</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Supported>
|
||||
</ComplexData>
|
||||
</Input>
|
||||
<Input minOccurs="0" maxOccurs="1">
|
||||
<ows:Identifier>source_field</ows:Identifier><!-- 5 -->
|
||||
<ows:Title>source field</ows:Title>
|
||||
<ows:Abstract>The field used to assign values to the source locations when the {in_value_raster} is not set. The value raster will take precedence over any setting for the {source_field}. If the {source_field} is floating point, an {in_value_raster} must be used. By setting the {in_value_raster}, the field set for the {source_field} parameter will be overridden by the value field of the {in_value_raster}.</ows:Abstract>
|
||||
<LiteralData>
|
||||
<ows:DataType ows:reference="xs:string"></ows:DataType>
|
||||
<ows:AnyValue/>
|
||||
</LiteralData>
|
||||
</Input>
|
||||
<Input minOccurs="0" maxOccurs="1">
|
||||
<ows:Identifier>maximum_distance</ows:Identifier><!-- 2 -->
|
||||
<ows:Title>maximum distance</ows:Title>
|
||||
<ows:Abstract>Defines the threshold that the accumulative distance values cannot exceed. The {maximum_distance} defines the extent for which the accumulative Euclidean distances are calculated. If an accumulative Euclidean distance value exceeds the {maximum_distance}, the output value for the cell location will be NoData. The default distance is to the edge of the output raster.</ows:Abstract>
|
||||
<LiteralData>
|
||||
<ows:DataType ows:reference="xs:integer"></ows:DataType>
|
||||
<ows:AnyValue/>
|
||||
</LiteralData>
|
||||
</Input>
|
||||
<Input minOccurs="0" maxOccurs="1">
|
||||
<ows:Identifier>cell_size</ows:Identifier><!-- 4 -->
|
||||
<ows:Title>cell size</ows:Title>
|
||||
<ows:Abstract>The cell size at which the output raster will be created. This will be the value in the environment if it is explicitly set. If it's not set in the environment, and if the in_source_data is a raster, the cell size will default to that of the in_source_data. If the in_source_data is a feature dataset, the cell size will default to the shorter of the width or height of the extent of input features in the input spatial reference, divided by 250.</ows:Abstract>
|
||||
<LiteralData>
|
||||
<ows:DataType ows:reference="xs:double"></ows:DataType>
|
||||
<ows:AnyValue/>
|
||||
</LiteralData>
|
||||
</Input>
|
||||
</DataInputs>
|
||||
<ProcessOutputs>
|
||||
<Output>
|
||||
<ows:Identifier>out_allocation_raster</ows:Identifier><!-- 1 -->
|
||||
<ows:Title>out allocation raster</ows:Title>
|
||||
<ows:Abstract>A raster that identifies the zone that could be reached with the least accumulative cost from each source location.</ows:Abstract>
|
||||
<ComplexOutput>
|
||||
<Default>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Default>
|
||||
<Supported>
|
||||
<Format>
|
||||
<MimeType>application/GeoTIFF</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Supported>
|
||||
</ComplexOutput>
|
||||
</Output>
|
||||
<Output>
|
||||
<ows:Identifier>out_distance_raster</ows:Identifier><!-- 6 -->
|
||||
<ows:Title>out distance raster</ows:Title>
|
||||
<ows:Abstract>The name of the output Euclidean distance raster. The distance raster identifies, for each cell, the Euclidean distance to the closest source cell, set of source cells, or source location.</ows:Abstract>
|
||||
<ComplexOutput>
|
||||
<Default>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Default>
|
||||
<Supported>
|
||||
<Format>
|
||||
<MimeType>application/GeoTIFF</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Supported>
|
||||
</ComplexOutput>
|
||||
</Output>
|
||||
<Output>
|
||||
<ows:Identifier>out_direction_raster</ows:Identifier><!-- 7 -->
|
||||
<ows:Title>out direction raster</ows:Title>
|
||||
<ows:Abstract>The name of the output (Euclidean) direction raster. The direction raster contains the calculated direction, in degrees, each cell center is from the closest source cell center. The range of values is 0 to 360 degrees, with 0 reserved for the source cells. Due east (right) is 90, and the values increase clockwise (180 is south, 270 is west, and 360 is north).</ows:Abstract>
|
||||
<ComplexOutput>
|
||||
<Default>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Default>
|
||||
<Supported>
|
||||
<Format>
|
||||
<MimeType>application/GeoTIFF</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Supported>
|
||||
</ComplexOutput>
|
||||
</Output>
|
||||
</ProcessOutputs>
|
||||
</ProcessDescription>
|
||||
</wps:ProcessDescriptions>
|
||||
|
||||
|
||||
@ -1,106 +0,0 @@
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<wps:ProcessDescriptions xmlns:wps="http://www.opengis.net/wps/1.0.0" xmlns:ows="http://www.opengis.net/ows/1.1" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.opengis.net/wps/1.0.0
|
||||
http://schemas.opengis.net/wps/1.0.0/wpsDescribeProcess_response.xsd" xml:lang="en-US" service="WPS" version="1.0.0">
|
||||
<ProcessDescription wps:processVersion="2" statusSupported="true" storeSupported="true">
|
||||
<ows:Identifier>org.n52.wps.ags.spatialanalyst.distance.euclideandirection</ows:Identifier><!-- ParameterCount=5 -->
|
||||
<ows:Title>EuclideanDirection_sa</ows:Title>
|
||||
<ows:Abstract>Calculates, for each cell, the direction, in degrees, to the nearest source. Uses ArcObjects library - Spatial Analyst</ows:Abstract>
|
||||
<DataInputs>
|
||||
<Input minOccurs="1" maxOccurs="1">
|
||||
<ows:Identifier>in_source_data</ows:Identifier><!-- 0 -->
|
||||
<ows:Title>in source data</ows:Title>
|
||||
<ows:Abstract>The input source locations. A raster or feature dataset that identifies the cells or locations whose values are assigned the output cell locations to which they are closest.</ows:Abstract>
|
||||
<ComplexData>
|
||||
<Default>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Default>
|
||||
<Supported>
|
||||
<Format>
|
||||
<MimeType>application/GeoTIFF</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
<Format>
|
||||
<MimeType>application/x-zipped-shape</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Supported>
|
||||
</ComplexData>
|
||||
</Input>
|
||||
<Input minOccurs="0" maxOccurs="1">
|
||||
<ows:Identifier>maximum_distance</ows:Identifier><!-- 2 -->
|
||||
<ows:Title>maximum distance</ows:Title>
|
||||
<ows:Abstract>Defines the threshold that the accumulative distance values cannot exceed. If an accumulative Euclidean distance value exceeds the {maximum_distance}, the output value for the cell location will be NoData. The {maximum_distance} defines the extent for which the accumulative Euclidean distances are calculated. The default distance is to the edge of the output raster.</ows:Abstract>
|
||||
<LiteralData>
|
||||
<ows:DataType ows:reference="xs:integer"></ows:DataType>
|
||||
<ows:AnyValue/>
|
||||
</LiteralData>
|
||||
</Input>
|
||||
<Input minOccurs="0" maxOccurs="1">
|
||||
<ows:Identifier>cell_size</ows:Identifier><!-- 3 -->
|
||||
<ows:Title>cell size</ows:Title>
|
||||
<ows:Abstract>The cell size at which the output raster will be created. This will be the value in the environment if it is explicitly set. If it's not set in the environment, and if the in_source_data is a raster, the cell size will default to that of the in_source_data. If the in_source_data is a feature dataset, the cell size will default to the shorter of the width or height of the extent of input features in the input spatial reference, divided by 250.</ows:Abstract>
|
||||
<LiteralData>
|
||||
<ows:DataType ows:reference="xs:double"></ows:DataType>
|
||||
<ows:AnyValue/>
|
||||
</LiteralData>
|
||||
</Input>
|
||||
</DataInputs>
|
||||
<ProcessOutputs>
|
||||
<Output>
|
||||
<ows:Identifier>out_direction_raster</ows:Identifier><!-- 1 -->
|
||||
<ows:Title>out direction raster</ows:Title>
|
||||
<ows:Abstract>The name of the output (Euclidean) direction raster. Contains the calculated direction in degrees each cell center is from the closest source cell center. The range of values is 0 to 360, with 0 reserved for the source cells. Due east (right) is 90 and the values increase clockwise (180 is south, 270 is west, and 360 is north).</ows:Abstract>
|
||||
<ComplexOutput>
|
||||
<Default>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Default>
|
||||
<Supported>
|
||||
<Format>
|
||||
<MimeType>application/GeoTIFF</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Supported>
|
||||
</ComplexOutput>
|
||||
</Output>
|
||||
<Output>
|
||||
<ows:Identifier>out_distance_raster</ows:Identifier><!-- 4 -->
|
||||
<ows:Title>out distance raster</ows:Title>
|
||||
<ows:Abstract>The name of the output Euclidean distance raster. The distance raster identifies, for each cell, the Euclidean distance to the closest source cell, set of source cells, or source location.</ows:Abstract>
|
||||
<ComplexOutput>
|
||||
<Default>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Default>
|
||||
<Supported>
|
||||
<Format>
|
||||
<MimeType>application/GeoTIFF</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Supported>
|
||||
</ComplexOutput>
|
||||
</Output>
|
||||
</ProcessOutputs>
|
||||
</ProcessDescription>
|
||||
</wps:ProcessDescriptions>
|
||||
|
||||
|
||||
@ -1,106 +0,0 @@
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<wps:ProcessDescriptions xmlns:wps="http://www.opengis.net/wps/1.0.0" xmlns:ows="http://www.opengis.net/ows/1.1" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.opengis.net/wps/1.0.0
|
||||
http://schemas.opengis.net/wps/1.0.0/wpsDescribeProcess_response.xsd" xml:lang="en-US" service="WPS" version="1.0.0">
|
||||
<ProcessDescription wps:processVersion="2" statusSupported="true" storeSupported="true">
|
||||
<ows:Identifier>org.n52.wps.ags.spatialanalyst.distance.euclideandistance</ows:Identifier><!-- ParameterCount=5 -->
|
||||
<ows:Title>EuclideanDistance_sa</ows:Title>
|
||||
<ows:Abstract>Calculates, for each cell, the Euclidean distance to the closest source. Uses ArcObjects library - Spatial Analyst</ows:Abstract>
|
||||
<DataInputs>
|
||||
<Input minOccurs="1" maxOccurs="1">
|
||||
<ows:Identifier>in_source_data</ows:Identifier><!-- 0 -->
|
||||
<ows:Title>in source data</ows:Title>
|
||||
<ows:Abstract>The input source locations. A raster or feature dataset that identifies the cells or locations to which the Euclidean distance for every cell location is calculated. If raster, it must be integer type. Distance is calculated only to the single closest source cell or location.</ows:Abstract>
|
||||
<ComplexData>
|
||||
<Default>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Default>
|
||||
<Supported>
|
||||
<Format>
|
||||
<MimeType>application/GeoTIFF</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
<Format>
|
||||
<MimeType>application/x-zipped-shape</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Supported>
|
||||
</ComplexData>
|
||||
</Input>
|
||||
<Input minOccurs="0" maxOccurs="1">
|
||||
<ows:Identifier>maximum_distance</ows:Identifier><!-- 2 -->
|
||||
<ows:Title>maximum distance</ows:Title>
|
||||
<ows:Abstract>Defines the threshold that the accumulative distance values cannot exceed. If an accumulative Euclidean distance value exceeds the {maximum_distance}, the output value for the cell location will be NoData. The {maximum_distance} defines the extent for which the accumulative Euclidean distances are calculated. The default distance is to the edge of the output raster.</ows:Abstract>
|
||||
<LiteralData>
|
||||
<ows:DataType ows:reference="xs:integer"></ows:DataType>
|
||||
<ows:AnyValue/>
|
||||
</LiteralData>
|
||||
</Input>
|
||||
<Input minOccurs="0" maxOccurs="1">
|
||||
<ows:Identifier>cell_size</ows:Identifier><!-- 3 -->
|
||||
<ows:Title>cell size</ows:Title>
|
||||
<ows:Abstract>The cell size at which the output raster will be created. This will be the value in the environment if it is explicitly set. If it's not set in the environment, and if the in_source_data is a raster, the cell size will default to that of the in_source_data. If the in_source_data is a feature dataset, the cell size will default to the shorter of the width or height of the extent of input features in the input spatial reference, divided by 250.</ows:Abstract>
|
||||
<LiteralData>
|
||||
<ows:DataType ows:reference="xs:double"></ows:DataType>
|
||||
<ows:AnyValue/>
|
||||
</LiteralData>
|
||||
</Input>
|
||||
</DataInputs>
|
||||
<ProcessOutputs>
|
||||
<Output>
|
||||
<ows:Identifier>out_distance_raster</ows:Identifier><!-- 1 -->
|
||||
<ows:Title>out distance raster</ows:Title>
|
||||
<ows:Abstract>The name of the output Euclidean distance raster. The distance raster identifies, for each cell, the Euclidean distance to the closest source cell, set of source cells, or source location.</ows:Abstract>
|
||||
<ComplexOutput>
|
||||
<Default>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Default>
|
||||
<Supported>
|
||||
<Format>
|
||||
<MimeType>application/GeoTIFF</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Supported>
|
||||
</ComplexOutput>
|
||||
</Output>
|
||||
<Output>
|
||||
<ows:Identifier>out_direction_raster</ows:Identifier><!-- 4 -->
|
||||
<ows:Title>out direction raster</ows:Title>
|
||||
<ows:Abstract>The name of the output Euclidean direction raster. The direction raster contains the calculated direction, in degrees, each cell center is from the closest source cell center. The range of values is 0 to 360 degrees, with 0 reserved for the source cells. Due east (right) is 90, and the values increase clockwise (180 is south, 270 is west, and 360 is north).</ows:Abstract>
|
||||
<ComplexOutput>
|
||||
<Default>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Default>
|
||||
<Supported>
|
||||
<Format>
|
||||
<MimeType>application/GeoTIFF</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Supported>
|
||||
</ComplexOutput>
|
||||
</Output>
|
||||
</ProcessOutputs>
|
||||
</ProcessDescription>
|
||||
</wps:ProcessDescriptions>
|
||||
|
||||
|
||||
@ -1,69 +0,0 @@
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<wps:ProcessDescriptions xmlns:wps="http://www.opengis.net/wps/1.0.0" xmlns:ows="http://www.opengis.net/ows/1.1" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.opengis.net/wps/1.0.0
|
||||
http://schemas.opengis.net/wps/1.0.0/wpsDescribeProcess_response.xsd" xml:lang="en-US" service="WPS" version="1.0.0">
|
||||
<ProcessDescription wps:processVersion="2" statusSupported="true" storeSupported="true"> <ows:Identifier>org.n52.wps.ags.spatialanalyst.extraction.extractbyattributes</ows:Identifier><!-- ParameterCount=3 -->
|
||||
<ows:Title>ExtractByAttributes_sa</ows:Title>
|
||||
<ows:Abstract>Extracts the cells of a raster based on a logical query. Uses ArcObjects library - Spatial Analyst</ows:Abstract>
|
||||
<DataInputs>
|
||||
<Input minOccurs="1" maxOccurs="1">
|
||||
<ows:Identifier>in_raster</ows:Identifier><!-- 0 -->
|
||||
<ows:Title>in raster</ows:Title>
|
||||
<ows:Abstract>The input raster from which cells will be extracted.</ows:Abstract>
|
||||
<ComplexData>
|
||||
<Default>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Default>
|
||||
<Supported>
|
||||
<Format>
|
||||
<MimeType>application/GeoTIFF</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Supported>
|
||||
</ComplexData>
|
||||
</Input>
|
||||
<Input minOccurs="1" maxOccurs="1">
|
||||
<ows:Identifier>where_clause</ows:Identifier><!-- 1 -->
|
||||
<ows:Title>where clause</ows:Title>
|
||||
<ows:Abstract>An SQL expression used to select a subset of raster cells. For information on SQL syntax, see SQL Reference.</ows:Abstract>
|
||||
<LiteralData>
|
||||
<ows:DataType ows:reference="xs:string"></ows:DataType>
|
||||
<ows:AnyValue/>
|
||||
</LiteralData>
|
||||
</Input>
|
||||
</DataInputs>
|
||||
<ProcessOutputs>
|
||||
<Output>
|
||||
<ows:Identifier>out raster</ows:Identifier><!-- 2 -->
|
||||
<ows:Title>out_raster</ows:Title>
|
||||
<ows:Abstract>The raster to be created.</ows:Abstract>
|
||||
<ComplexOutput>
|
||||
<Default>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Default>
|
||||
<Supported>
|
||||
<Format>
|
||||
<MimeType>application/GeoTIFF</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Supported>
|
||||
</ComplexOutput>
|
||||
</Output>
|
||||
</ProcessOutputs>
|
||||
</ProcessDescription>
|
||||
</wps:ProcessDescriptions>
|
||||
|
||||
|
||||
@ -1,92 +0,0 @@
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<wps:ProcessDescriptions xmlns:wps="http://www.opengis.net/wps/1.0.0" xmlns:ows="http://www.opengis.net/ows/1.1" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.opengis.net/wps/1.0.0
|
||||
http://schemas.opengis.net/wps/1.0.0/wpsDescribeProcess_response.xsd" xml:lang="en-US" service="WPS" version="1.0.0">
|
||||
<ProcessDescription wps:processVersion="2" statusSupported="true" storeSupported="true">
|
||||
<ows:Identifier>org.n52.wps.ags.spatialanalyst.extraction.extractbycircle</ows:Identifier><!-- AGS_InternalParameterCount=5 -->
|
||||
<ows:Title>ExtractByCircle</ows:Title>
|
||||
<ows:Abstract>Extracts the cells of a raster based on a circle. Uses ArcObjects library - Spatial Analyst</ows:Abstract>
|
||||
<DataInputs>
|
||||
<Input minOccurs="1" maxOccurs="1">
|
||||
<ows:Identifier>in_raster</ows:Identifier><!-- 0 -->
|
||||
<ows:Title>in raster</ows:Title>
|
||||
<ows:Abstract>The input raster from which cells will be extracted.</ows:Abstract>
|
||||
<ComplexData>
|
||||
<Default>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Default>
|
||||
<Supported>
|
||||
<Format>
|
||||
<MimeType>application/GeoTIFF</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Supported>
|
||||
</ComplexData>
|
||||
</Input>
|
||||
<Input minOccurs="1" maxOccurs="1">
|
||||
<ows:Identifier>center_point</ows:Identifier><!-- 1 -->
|
||||
<ows:Title>center point</ows:Title>
|
||||
<ows:Abstract>Center coordinate (x,y) of circle defining the area to be extracted. The coordinates are specified in the same map units as the in_raster.</ows:Abstract>
|
||||
<LiteralData>
|
||||
<ows:DataType ows:reference="xs:string"></ows:DataType>
|
||||
<ows:AnyValue/>
|
||||
</LiteralData>
|
||||
</Input>
|
||||
<Input minOccurs="1" maxOccurs="1">
|
||||
<ows:Identifier>radius</ows:Identifier><!-- 2 -->
|
||||
<ows:Title>radius</ows:Title>
|
||||
<ows:Abstract>Radius of circle defining the area to be extracted. The radius is specified in map units and is in the same units as the in_raster.</ows:Abstract>
|
||||
<LiteralData>
|
||||
<ows:DataType ows:reference="xs:double"></ows:DataType>
|
||||
<ows:AnyValue/>
|
||||
</LiteralData>
|
||||
</Input>
|
||||
<Input minOccurs="0" maxOccurs="1">
|
||||
<ows:Identifier>extraction_area</ows:Identifier><!-- 4 -->
|
||||
<ows:Title>extraction area</ows:Title>
|
||||
<ows:Abstract>Identifies whether to extract cells inside or outside the input circle. INSIDE — A keyword specifying that the cells inside the input circle should be selected and written to the output raster. All cells outside the circle will receive NoData on the output raster. OUTSIDE — A keyword specifying that the cells outside the input circle should be selected and written to the output raster. All cells inside the circle will receive NoData on the output raster.
|
||||
</ows:Abstract>
|
||||
<LiteralData>
|
||||
<ows:DataType ows:reference="xs:string"></ows:DataType>
|
||||
<ows:AllowedValues>
|
||||
<ows:Value>INSIDE</ows:Value>
|
||||
<ows:Value>OUTSIDE</ows:Value>
|
||||
</ows:AllowedValues>
|
||||
</LiteralData>
|
||||
</Input>
|
||||
</DataInputs>
|
||||
<ProcessOutputs>
|
||||
<Output>
|
||||
<ows:Identifier>out_raster</ows:Identifier><!-- 3 -->
|
||||
<ows:Title>out raster</ows:Title>
|
||||
<ows:Abstract>The raster to be created.</ows:Abstract>
|
||||
<ComplexOutput>
|
||||
<Default>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Default>
|
||||
<Supported>
|
||||
<Format>
|
||||
<MimeType>application/GeoTIFF</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Supported>
|
||||
</ComplexOutput>
|
||||
</Output>
|
||||
</ProcessOutputs>
|
||||
</ProcessDescription>
|
||||
</wps:ProcessDescriptions>
|
||||
|
||||
|
||||
@ -1,84 +0,0 @@
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<wps:ProcessDescriptions xmlns:wps="http://www.opengis.net/wps/1.0.0" xmlns:ows="http://www.opengis.net/ows/1.1" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.opengis.net/wps/1.0.0
|
||||
http://schemas.opengis.net/wps/1.0.0/wpsDescribeProcess_response.xsd" xml:lang="en-US" service="WPS" version="1.0.0">
|
||||
<ProcessDescription wps:processVersion="2" statusSupported="true" storeSupported="true">
|
||||
<ows:Identifier>org.n52.wps.ags.spatialanalyst.extraction.extractbymask</ows:Identifier><!-- ParameterCount=3 -->
|
||||
<ows:Title>ExtractByMask_sa</ows:Title>
|
||||
<ows:Abstract>Extracts the cells of a raster that correspond to the areas defined by a mask. Uses ArcObjects library - Spatial Analyst</ows:Abstract>
|
||||
<DataInputs>
|
||||
<Input minOccurs="1" maxOccurs="1">
|
||||
<ows:Identifier>in_raster</ows:Identifier><!-- 0 -->
|
||||
<ows:Title>in raster</ows:Title>
|
||||
<ows:Abstract>The input raster from which cells will be extracted.</ows:Abstract>
|
||||
<ComplexData>
|
||||
<Default>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Default>
|
||||
<Supported>
|
||||
<Format>
|
||||
<MimeType>application/GeoTIFF</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Supported>
|
||||
</ComplexData>
|
||||
</Input>
|
||||
<Input minOccurs="1" maxOccurs="1">
|
||||
<ows:Identifier>in_mask_data</ows:Identifier><!-- 1 -->
|
||||
<ows:Title>input mask data</ows:Title>
|
||||
<ows:Abstract>Input mask data defining areas to extract. This is a raster or feature dataset. When the in_mask_data is a raster, NoData cells on the mask will be assigned NoData values on the output raster.</ows:Abstract>
|
||||
<ComplexData>
|
||||
<Default>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Default>
|
||||
<Supported>
|
||||
<Format>
|
||||
<MimeType>application/GeoTIFF</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Supported>
|
||||
</ComplexData>
|
||||
</Input>
|
||||
</DataInputs>
|
||||
<ProcessOutputs>
|
||||
<Output>
|
||||
<ows:Identifier>out_raster</ows:Identifier><!-- 2 -->
|
||||
<ows:Title>out raster</ows:Title>
|
||||
<ows:Abstract>The raster to be created.</ows:Abstract>
|
||||
<ComplexOutput>
|
||||
<Default>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Default>
|
||||
<Supported>
|
||||
<Format>
|
||||
<MimeType>application/GeoTIFF</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Supported>
|
||||
</ComplexOutput>
|
||||
</Output>
|
||||
</ProcessOutputs>
|
||||
</ProcessDescription>
|
||||
</wps:ProcessDescriptions>
|
||||
|
||||
|
||||
@ -1,83 +0,0 @@
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<wps:ProcessDescriptions xmlns:wps="http://www.opengis.net/wps/1.0.0" xmlns:ows="http://www.opengis.net/ows/1.1" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.opengis.net/wps/1.0.0
|
||||
http://schemas.opengis.net/wps/1.0.0/wpsDescribeProcess_response.xsd" xml:lang="en-US" service="WPS" version="1.0.0">
|
||||
<ProcessDescription wps:processVersion="2" statusSupported="true" storeSupported="true">
|
||||
<ows:Identifier>org.n52.wps.ags.spatialanalyst.extraction.extractbypoints</ows:Identifier><!-- AGS_InternalParameterCount=4 -->
|
||||
<ows:Title>ExtractByPoints_sa</ows:Title>
|
||||
<ows:Abstract>Extracts the cells of a raster based on points. Uses ArcObjects library - Spatial Analyst</ows:Abstract>
|
||||
<DataInputs>
|
||||
<Input minOccurs="1" maxOccurs="1">
|
||||
<ows:Identifier>in_raster</ows:Identifier><!-- 0 -->
|
||||
<ows:Title>in raster</ows:Title>
|
||||
<ows:Abstract>The input raster from which cells will be extracted.</ows:Abstract>
|
||||
<ComplexData>
|
||||
<Default>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Default>
|
||||
<Supported>
|
||||
<Format>
|
||||
<MimeType>application/GeoTIFF</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Supported>
|
||||
</ComplexData>
|
||||
</Input>
|
||||
<Input minOccurs="1" maxOccurs="1000">
|
||||
<ows:Identifier>points</ows:Identifier><!-- 1 -->
|
||||
<ows:Title>points</ows:Title>
|
||||
<ows:Abstract>The points where values will be extracted from the raster. The points are specified as x,y coordinate pairs. The points are in the same map units as in_raster.</ows:Abstract>
|
||||
<LiteralData>
|
||||
<ows:DataType ows:reference="xs:string"></ows:DataType>
|
||||
<ows:AnyValue/>
|
||||
</LiteralData>
|
||||
</Input>
|
||||
<Input minOccurs="0" maxOccurs="1">
|
||||
<ows:Identifier>extraction_area</ows:Identifier><!-- 3 -->
|
||||
<ows:Title>extraction area</ows:Title>
|
||||
<ows:Abstract>Identifies whether to extract cells inside or outside the input points. INSIDE — A keyword specifying that the cell in which the selected point falls will be written to the output raster. All cells outside the box will receive NoData on the output raster. OUTSIDE — A keyword specifying that the cells outside the input points should be selected and written to the output raster.
|
||||
</ows:Abstract>
|
||||
<LiteralData>
|
||||
<ows:DataType ows:reference="xs:string"></ows:DataType>
|
||||
<ows:AllowedValues>
|
||||
<ows:Value>INSIDE</ows:Value>
|
||||
<ows:Value>OUTSIDE</ows:Value>
|
||||
</ows:AllowedValues>
|
||||
</LiteralData>
|
||||
</Input>
|
||||
</DataInputs>
|
||||
<ProcessOutputs>
|
||||
<Output>
|
||||
<ows:Identifier>out_raster</ows:Identifier><!-- 2 -->
|
||||
<ows:Title>out raster</ows:Title>
|
||||
<ows:Abstract>The raster to be created.</ows:Abstract>
|
||||
<ComplexOutput>
|
||||
<Default>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Default>
|
||||
<Supported>
|
||||
<Format>
|
||||
<MimeType>application/GeoTIFF</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Supported>
|
||||
</ComplexOutput>
|
||||
</Output>
|
||||
</ProcessOutputs>
|
||||
</ProcessDescription>
|
||||
</wps:ProcessDescriptions>
|
||||
|
||||
|
||||
@ -1,83 +0,0 @@
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<wps:ProcessDescriptions xmlns:wps="http://www.opengis.net/wps/1.0.0" xmlns:ows="http://www.opengis.net/ows/1.1" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.opengis.net/wps/1.0.0
|
||||
http://schemas.opengis.net/wps/1.0.0/wpsDescribeProcess_response.xsd" xml:lang="en-US" service="WPS" version="1.0.0">
|
||||
<ProcessDescription wps:processVersion="2" statusSupported="true" storeSupported="true">
|
||||
<ows:Identifier>org.n52.wps.ags.spatialanalyst.extraction.extractbypolygon</ows:Identifier><!-- ParameterCount=4 -->
|
||||
<ows:Title>ExtractByPolygon_sa</ows:Title>
|
||||
<ows:Abstract>Extracts the cells of a raster based on a polygon. Uses ArcObjects library - Spatial Analyst</ows:Abstract>
|
||||
<DataInputs>
|
||||
<Input minOccurs="1" maxOccurs="1">
|
||||
<ows:Identifier>in_raster</ows:Identifier><!-- 0 -->
|
||||
<ows:Title>in_raster</ows:Title>
|
||||
<ows:Abstract>The input raster from which cells will be extracted.</ows:Abstract>
|
||||
<ComplexData>
|
||||
<Default>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Default>
|
||||
<Supported>
|
||||
<Format>
|
||||
<MimeType>application/GeoTIFF</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Supported>
|
||||
</ComplexData>
|
||||
</Input>
|
||||
<Input minOccurs="1" maxOccurs="1000">
|
||||
<ows:Identifier>polygon</ows:Identifier><!-- 1 -->
|
||||
<ows:Title>polygon</ows:Title>
|
||||
<ows:Abstract>Polygon that defines the area to be extracted. X,Y coordinates define the vertices of the polygon.</ows:Abstract>
|
||||
<LiteralData>
|
||||
<ows:DataType ows:reference="xs:string"></ows:DataType>
|
||||
<ows:AnyValue/>
|
||||
</LiteralData>
|
||||
</Input>
|
||||
<Input minOccurs="0" maxOccurs="1">
|
||||
<ows:Identifier>extraction_area</ows:Identifier><!-- 3 -->
|
||||
<ows:Title>extraction area</ows:Title>
|
||||
<ows:Abstract>Identifies whether to extract cells inside or outside the input polygon. INSIDE — A keyword specifying that the cells inside the input polygon should be selected and written to the output raster. All cells outside the polygon will receive NoData values on the output raster. OUTSIDE — A keyword specifying that the cells outside the input polygon should be selected and written to the output raster. All cells inside the polygon will receive NoData values on the output grid.
|
||||
</ows:Abstract>
|
||||
<LiteralData>
|
||||
<ows:DataType ows:reference="xs:string"></ows:DataType>
|
||||
<ows:AllowedValues>
|
||||
<ows:Value>INSIDE</ows:Value>
|
||||
<ows:Value>OUTSIDE</ows:Value>
|
||||
</ows:AllowedValues>
|
||||
</LiteralData>
|
||||
</Input>
|
||||
</DataInputs>
|
||||
<ProcessOutputs>
|
||||
<Output>
|
||||
<ows:Identifier>out_raster</ows:Identifier><!-- 2 -->
|
||||
<ows:Title>out raster</ows:Title>
|
||||
<ows:Abstract>The raster to be created.</ows:Abstract>
|
||||
<ComplexOutput>
|
||||
<Default>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Default>
|
||||
<Supported>
|
||||
<Format>
|
||||
<MimeType>application/GeoTIFF</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Supported>
|
||||
</ComplexOutput>
|
||||
</Output>
|
||||
</ProcessOutputs>
|
||||
</ProcessDescription>
|
||||
</wps:ProcessDescriptions>
|
||||
|
||||
|
||||
@ -1,83 +0,0 @@
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<wps:ProcessDescriptions xmlns:wps="http://www.opengis.net/wps/1.0.0" xmlns:ows="http://www.opengis.net/ows/1.1" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.opengis.net/wps/1.0.0
|
||||
http://schemas.opengis.net/wps/1.0.0/wpsDescribeProcess_response.xsd" xml:lang="en-US" service="WPS" version="1.0.0">
|
||||
<ProcessDescription wps:processVersion="2" statusSupported="true" storeSupported="true">
|
||||
<ows:Identifier>org.n52.wps.ags.spatialanalyst.extraction.extractbyrectangle</ows:Identifier><!-- ParameterCount=4 -->
|
||||
<ows:Title>ExtractByRectangle_sa</ows:Title>
|
||||
<ows:Abstract>Extracts the cells of a raster based on a rectangle. Uses ArcObjects library - Spatial Analyst</ows:Abstract>
|
||||
<DataInputs>
|
||||
<Input minOccurs="1" maxOccurs="1">
|
||||
<ows:Identifier>in_raster</ows:Identifier><!-- 0 -->
|
||||
<ows:Title>inp raster</ows:Title>
|
||||
<ows:Abstract>The input raster from which cells will be extracted.</ows:Abstract>
|
||||
<ComplexData>
|
||||
<Default>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Default>
|
||||
<Supported>
|
||||
<Format>
|
||||
<MimeType>application/GeoTIFF</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Supported>
|
||||
</ComplexData>
|
||||
</Input>
|
||||
<Input minOccurs="1" maxOccurs="1">
|
||||
<ows:Identifier>rectangle</ows:Identifier><!-- 1 -->
|
||||
<ows:Title>rectangle</ows:Title>
|
||||
<ows:Abstract>X minimum and y minimum define the lower-left coordinates of the area to be extracted, and x maximum and y maximum define the upper-right coordinates.</ows:Abstract>
|
||||
<LiteralData>
|
||||
<ows:DataType ows:reference="xs:string"></ows:DataType>
|
||||
<ows:AnyValue/>
|
||||
</LiteralData>
|
||||
</Input>
|
||||
<Input minOccurs="0" maxOccurs="1">
|
||||
<ows:Identifier>extraction_area</ows:Identifier><!-- 3 -->
|
||||
<ows:Title>extraction area</ows:Title>
|
||||
<ows:Abstract>Identifies whether to extract cells inside or outside the input rectangle. INSIDE — A keyword specifying that the cells inside the input rectangle should be selected and written to the output raster. All cells outside the rectangle will receive NoData values on the output raster. OUTSIDE — A keyword specifying that the cells outside the input rectangle should be selected and written to the output raster. All cells inside the rectangle will receive NoData values on the output raster.
|
||||
</ows:Abstract>
|
||||
<LiteralData>
|
||||
<ows:DataType ows:reference="xs:string"></ows:DataType>
|
||||
<ows:AllowedValues>
|
||||
<ows:Value>INSIDE</ows:Value>
|
||||
<ows:Value>OUTSIDE</ows:Value>
|
||||
</ows:AllowedValues>
|
||||
</LiteralData>
|
||||
</Input>
|
||||
</DataInputs>
|
||||
<ProcessOutputs>
|
||||
<Output>
|
||||
<ows:Identifier>out_raster</ows:Identifier><!-- 2 -->
|
||||
<ows:Title>out raster</ows:Title>
|
||||
<ows:Abstract>The raster to be created.</ows:Abstract>
|
||||
<ComplexOutput>
|
||||
<Default>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Default>
|
||||
<Supported>
|
||||
<Format>
|
||||
<MimeType>application/GeoTIFF</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Supported>
|
||||
</ComplexOutput>
|
||||
</Output>
|
||||
</ProcessOutputs>
|
||||
</ProcessDescription>
|
||||
</wps:ProcessDescriptions>
|
||||
|
||||
|
||||
@ -1,96 +0,0 @@
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<wps:ProcessDescriptions xmlns:wps="http://www.opengis.net/wps/1.0.0" xmlns:ows="http://www.opengis.net/ows/1.1" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.opengis.net/wps/1.0.0
|
||||
http://schemas.opengis.net/wps/1.0.0/wpsDescribeProcess_response.xsd" xml:lang="en-US" service="WPS" version="1.0.0">
|
||||
<ProcessDescription wps:processVersion="2" statusSupported="true" storeSupported="true">
|
||||
<ows:Identifier>org.n52.wps.ags.spatialanalyst.extraction.extractvaluestopoints</ows:Identifier><!-- ParameterCount=5 -->
|
||||
<ows:Title>ExtractValuesToPoints_sa</ows:Title>
|
||||
<ows:Abstract>Extracts the cell values of a raster based on a set of points. Uses ArcObjects library - Spatial Analyst</ows:Abstract>
|
||||
<DataInputs>
|
||||
<Input minOccurs="1" maxOccurs="1">
|
||||
<ows:Identifier>in_point_feature</ows:Identifier><!-- 0 -->
|
||||
<ows:Title>in point feature</ows:Title>
|
||||
<ows:Abstract>The input point features to which you want to add raster values.</ows:Abstract>
|
||||
<ComplexData>
|
||||
<Default>
|
||||
<Format>
|
||||
<MimeType>application/x-zipped-shp</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Default>
|
||||
<Supported>
|
||||
<Format>
|
||||
<MimeType>application/x-zipped-shp</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Supported>
|
||||
</ComplexData>
|
||||
</Input>
|
||||
<Input minOccurs="1" maxOccurs="1">
|
||||
<ows:Identifier>in_raster</ows:Identifier><!-- 1 -->
|
||||
<ows:Title>in raster</ows:Title>
|
||||
<ows:Abstract>The name of a raster dataset whose values you want to add to the input point features.</ows:Abstract>
|
||||
<ComplexData>
|
||||
<Default>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Default>
|
||||
<Supported>
|
||||
<Format>
|
||||
<MimeType>application/GeoTIFF</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Supported>
|
||||
</ComplexData>
|
||||
</Input>
|
||||
<Input minOccurs="1" maxOccurs="1">
|
||||
<ows:Identifier>interpolate_values</ows:Identifier><!-- 2 -->
|
||||
<ows:Title>interpolatie values</ows:Title>
|
||||
<ows:Abstract>Specifies whether or not interpolation will be used. NONE — No interpolation will be applied; the value of the cell center will be used. INTERPOLATE — The value of the cell will be calculated from the adjacent cells with valid values using bilinear interpolation. NoData values will be ignored in the interpolation unless all adjacent cells are NoData.
|
||||
</ows:Abstract>
|
||||
<LiteralData>
|
||||
<ows:DataType ows:reference="xs:boolean"></ows:DataType>
|
||||
<ows:AnyValue/>
|
||||
</LiteralData>
|
||||
</Input>
|
||||
<Input minOccurs="1" maxOccurs="1">
|
||||
<ows:Identifier>add_attributes</ows:Identifier><!-- 3 -->
|
||||
<ows:Title>interpolation as boolean</ows:Title>
|
||||
<ows:Abstract>Determines if the raster attributes are written to the output point feature dataset. VALUE_ONLY — Only the value of the input raster is added to the point attributes. This is the default. ALL — All the fields from the input raster (except Count) will be added to the point attributes.
|
||||
</ows:Abstract>
|
||||
<LiteralData>
|
||||
<ows:DataType ows:reference="xs:boolean"></ows:DataType>
|
||||
<ows:AnyValue/>
|
||||
</LiteralData>
|
||||
</Input>
|
||||
</DataInputs>
|
||||
<ProcessOutputs>
|
||||
<Output>
|
||||
<ows:Identifier>out_point_feature</ows:Identifier><!-- 2 -->
|
||||
<ows:Title>out point feature</ows:Title>
|
||||
<ows:Abstract>The output point feature dataset containing the extracted raster values.</ows:Abstract>
|
||||
<ComplexOutput>
|
||||
<Default>
|
||||
<Format>
|
||||
<MimeType>application/x-zipped-shp</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Default>
|
||||
<Supported>
|
||||
<Format>
|
||||
<MimeType>application/x-zipped-shp</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Supported>
|
||||
</ComplexOutput>
|
||||
</Output>
|
||||
</ProcessOutputs>
|
||||
</ProcessDescription>
|
||||
</wps:ProcessDescriptions>
|
||||
|
||||
|
||||
@ -1,98 +0,0 @@
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<wps:ProcessDescriptions xmlns:wps="http://www.opengis.net/wps/1.0.0" xmlns:ows="http://www.opengis.net/ows/1.1" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.opengis.net/wps/1.0.0
|
||||
http://schemas.opengis.net/wps/1.0.0/wpsDescribeProcess_response.xsd" xml:lang="en-US" service="WPS" version="1.0.0">
|
||||
<ProcessDescription wps:processVersion="2" statusSupported="true" storeSupported="true">
|
||||
<ows:Identifier>org.n52.wps.ags.spatialanalyst.extraction.sample</ows:Identifier><!-- ParameterCount=4 -->
|
||||
<ows:Title>Sample_sa</ows:Title>
|
||||
<ows:Abstract>Creates a table that shows the values of cells from a raster, or set of rasters, for defined locations. The locations are defined by raster cells or by a set of points. Uses ArcObjects library - Spatial Analyst</ows:Abstract>
|
||||
<DataInputs>
|
||||
<Input minOccurs="1" maxOccurs="1">
|
||||
<ows:Identifier>in_location_data</ows:Identifier><!-- 1 -->
|
||||
<ows:Title>in location data</ows:Title>
|
||||
<ows:Abstract>Data identifying positions at which you want a sample taken. This can be a raster or a point feature dataset.</ows:Abstract>
|
||||
<ComplexData>
|
||||
<Default>
|
||||
<Format>
|
||||
<MimeType>application/x-zipped-shp</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Default>
|
||||
<Supported>
|
||||
<Format>
|
||||
<MimeType>application/x-zipped-shp</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
<Format>
|
||||
<MimeType>application/GeoTIFF</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Supported>
|
||||
</ComplexData>
|
||||
</Input>
|
||||
<Input minOccurs="1" maxOccurs="1000">
|
||||
<ows:Identifier>in_rasters</ows:Identifier><!-- 0 -->
|
||||
<ows:Title>in rasters</ows:Title>
|
||||
<ows:Abstract>The rasters whose values will be sampled based on the input location data.</ows:Abstract>
|
||||
<ComplexData>
|
||||
<Default>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Default>
|
||||
<Supported>
|
||||
<Format>
|
||||
<MimeType>application/GeoTIFF</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Supported>
|
||||
</ComplexData>
|
||||
</Input>
|
||||
<Input minOccurs="0" maxOccurs="1">
|
||||
<ows:Identifier>resampling_type</ows:Identifier><!-- 3 -->
|
||||
<ows:Title>resampling type</ows:Title>
|
||||
<ows:Abstract>Resampling algorithm used when sampling a raster. NEAREST — Nearest neighbor assignment. BILINEAR — Bilinear interpolation. CUBIC — Cubic convolution.
|
||||
</ows:Abstract>
|
||||
<LiteralData>
|
||||
<ows:DataType ows:reference="xs:string"></ows:DataType>
|
||||
<ows:AllowedValues>
|
||||
<ows:Value>NEAREST</ows:Value>
|
||||
<ows:Value>BILINEAR</ows:Value>
|
||||
<ows:Value>CUBIC</ows:Value>
|
||||
</ows:AllowedValues>
|
||||
</LiteralData>
|
||||
</Input>
|
||||
</DataInputs>
|
||||
<ProcessOutputs>
|
||||
<Output>
|
||||
<ows:Identifier>out_table</ows:Identifier><!-- 2 -->
|
||||
<ows:Title>out table</ows:Title>
|
||||
<ows:Abstract>Output table holding the sampled cell values.</ows:Abstract>
|
||||
<ComplexOutput>
|
||||
<Default>
|
||||
<Format>
|
||||
<MimeType>application/dbf</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Default>
|
||||
<Supported>
|
||||
<Format>
|
||||
<MimeType>application/dbf</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Supported>
|
||||
</ComplexOutput>
|
||||
</Output>
|
||||
</ProcessOutputs>
|
||||
</ProcessDescription>
|
||||
</wps:ProcessDescriptions>
|
||||
|
||||
|
||||
@ -1,105 +0,0 @@
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<wps:ProcessDescriptions xmlns:wps="http://www.opengis.net/wps/1.0.0" xmlns:ows="http://www.opengis.net/ows/1.1" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.opengis.net/wps/1.0.0
|
||||
http://schemas.opengis.net/wps/1.0.0/wpsDescribeProcess_response.xsd" xml:lang="en-US" service="WPS" version="1.0.0">
|
||||
<ProcessDescription wps:processVersion="2" statusSupported="true" storeSupported="true">
|
||||
<ows:Identifier>org.n52.wps.ags.spatialanalyst.math.generalization.aggregate</ows:Identifier><!-- ParameterCount=6 -->
|
||||
<ows:Title>Aggregate_sa</ows:Title>
|
||||
<ows:Abstract>Generates a reduced resolution version of a raster. Uses ArcObjects library - Spatial Analyst</ows:Abstract>
|
||||
<DataInputs>
|
||||
<Input minOccurs="1" maxOccurs="1">
|
||||
<ows:Identifier>in_raster</ows:Identifier><!-- 0 -->
|
||||
<ows:Title>in raster</ows:Title>
|
||||
<ows:Abstract>The input raster to aggregate.</ows:Abstract>
|
||||
<ComplexData>
|
||||
<Default>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Default>
|
||||
<Supported>
|
||||
<Format>
|
||||
<MimeType>application/GeoTIFF</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Supported>
|
||||
</ComplexData>
|
||||
</Input>
|
||||
<Input minOccurs="1" maxOccurs="1">
|
||||
<ows:Identifier>cell factor</ows:Identifier><!-- 2 -->
|
||||
<ows:Title>cell factor</ows:Title>
|
||||
<ows:Abstract>The factor by which to multiply the cell size of the input raster to obtain the desired resolution for the output raster. For example, a cell_factor of three would result in an output cell size three times larger than that of the input raster. The cell_factor must be an integer greater than one.</ows:Abstract>
|
||||
<LiteralData>
|
||||
<ows:DataType ows:reference="xs:long"></ows:DataType>
|
||||
<ows:AnyValue/>
|
||||
</LiteralData>
|
||||
</Input>
|
||||
<Input minOccurs="0" maxOccurs="1">
|
||||
<ows:Identifier>aggregation type</ows:Identifier><!-- 3 -->
|
||||
<ows:Title>aggregation type</ows:Title>
|
||||
<ows:Abstract>Establishes how the value for each output cell will be determined. The output value for each cell can be the sum, maximum, mean, median, or minimum value of the input cells that the coarser output cell will encompass. Sum is the default value.</ows:Abstract>
|
||||
<LiteralData>
|
||||
<ows:DataType ows:reference="xs:string"></ows:DataType>
|
||||
<ows:AllowedValues>
|
||||
<ows:Value>SUM</ows:Value>
|
||||
<ows:Value>MAXIMUM</ows:Value>
|
||||
<ows:Value>MEAN</ows:Value>
|
||||
<ows:Value>MINIMUM</ows:Value>
|
||||
<ows:Value>MEDIAN</ows:Value>
|
||||
</ows:AllowedValues>
|
||||
</LiteralData>
|
||||
</Input>
|
||||
<Input minOccurs="0" maxOccurs="1">
|
||||
<ows:Identifier>extent_handling</ows:Identifier><!-- 4 -->
|
||||
<ows:Title>extent handling</ows:Title>
|
||||
<ows:Abstract>Defines how to handle the boundaries of the input raster when its rows or columns are not a multiple of the cell factor. If the number of rows and columns in the input grid is a multiple of the cell_factor, these keywords are not used. EXPAND — Expands the bottom or right boundaries of the input raster so the total number of cells in a row or column is a multiple of the cell_factor. Expanded cells are given a value of NoData. With this option, the output raster can cover a larger spatial extent than the input raster. TRUNCATE — Reduces the number of rows or columns in the output raster by one. This will truncate the remaining cells on the bottom or right boundaries of the input raster, making the number of rows or columns in the input raster a multiple of the cell_factor. With this option, the output raster can cover a smaller spatial extent than the input raster.
|
||||
</ows:Abstract>
|
||||
<LiteralData>
|
||||
<ows:DataType ows:reference="xs:boolean"></ows:DataType>
|
||||
<ows:AnyValue/>
|
||||
</LiteralData>
|
||||
</Input>
|
||||
<Input minOccurs="0" maxOccurs="1">
|
||||
<ows:Identifier>ignore_nodata</ows:Identifier><!-- 5 -->
|
||||
<ows:Title>ignore nodata</ows:Title>
|
||||
<ows:Abstract>Denotes whether NoData values are ignored by the aggregation calculation. DATA — Specifies that if NoData values exist for any of the cells that fall within the spatial extent of a larger cell on the output raster, the NoData values will be ignored when determining the value for output cell locations. Only input cells within the extent of the output cell that have data values will be used in determining the value of the output cell. NODATA — Specifies that if any cell that falls within the spatial extent of a larger cell on the output raster has a value of NoData, the value for that output cell location will be NoData. When the NODATA keyword is used, it is implied that when cells within an aggregation contain the NoData value, there is insufficient information to perform the specified calculations necessary to determine an output value.
|
||||
</ows:Abstract>
|
||||
<LiteralData>
|
||||
<ows:DataType ows:reference="xs:boolean"></ows:DataType>
|
||||
<ows:AnyValue/>
|
||||
</LiteralData>
|
||||
</Input>
|
||||
</DataInputs>
|
||||
<ProcessOutputs>
|
||||
<Output>
|
||||
<ows:Identifier>out_raster</ows:Identifier><!-- 1 -->
|
||||
<ows:Title>out raster</ows:Title>
|
||||
<ows:Abstract>The raster to be created.</ows:Abstract>
|
||||
<ComplexOutput>
|
||||
<Default>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Default>
|
||||
<Supported>
|
||||
<Format>
|
||||
<MimeType>application/GeoTIFF</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Supported>
|
||||
</ComplexOutput>
|
||||
</Output>
|
||||
</ProcessOutputs>
|
||||
</ProcessDescription>
|
||||
</wps:ProcessDescriptions>
|
||||
|
||||
|
||||
@ -1,85 +0,0 @@
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<wps:ProcessDescriptions xmlns:wps="http://www.opengis.net/wps/1.0.0" xmlns:ows="http://www.opengis.net/ows/1.1" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.opengis.net/wps/1.0.0
|
||||
http://schemas.opengis.net/wps/1.0.0/wpsDescribeProcess_response.xsd" xml:lang="en-US" service="WPS" version="1.0.0">
|
||||
<ProcessDescription wps:processVersion="2" statusSupported="true" storeSupported="true">
|
||||
<ows:Identifier>org.n52.wps.ags.spatialanalyst.math.generalization.boundaryclean</ows:Identifier><!-- ParameterCount=4 -->
|
||||
<ows:Title>BoundaryClean</ows:Title>
|
||||
<ows:Abstract>Smoothes the boundary between zones by expanding and shrinking it. Uses ArcObjects library - Spatial Analyst</ows:Abstract>
|
||||
<DataInputs>
|
||||
<Input minOccurs="1" maxOccurs="1">
|
||||
<ows:Identifier>in_raster</ows:Identifier><!-- 0 -->
|
||||
<ows:Title>in raster</ows:Title>
|
||||
<ows:Abstract>The input raster to which Boundary Clean is applied.</ows:Abstract>
|
||||
<ComplexData>
|
||||
<Default>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Default>
|
||||
<Supported>
|
||||
<Format>
|
||||
<MimeType>application/GeoTIFF</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Supported>
|
||||
</ComplexData>
|
||||
</Input>
|
||||
<Input minOccurs="0" maxOccurs="1">
|
||||
<ows:Identifier>sort_type</ows:Identifier><!-- 2 -->
|
||||
<ows:Title>sort type</ows:Title>
|
||||
<ows:Abstract>Specifies the type of sorting. This determines the priority of cells to expand into their neighbors. NO_SORT — Does no sorting by size. Zones with larger values have a higher priority to expand into zones with smaller values. This is the default. DESCEND — Sorts zones in descending order by size. Zones with larger total areas have a higher priority to expand into zones with smaller total areas. ASCEND — Sorts zones in ascending order by size. Zones with smaller total areas have a higher priority to expand into zones with larger total areas.
|
||||
</ows:Abstract>
|
||||
<LiteralData>
|
||||
<ows:DataType ows:reference="xs:string"></ows:DataType>
|
||||
<ows:AllowedValues>
|
||||
<ows:Value>NO_SORT</ows:Value>
|
||||
<ows:Value>DESCEND</ows:Value>
|
||||
<ows:Value>ASCEND</ows:Value>
|
||||
</ows:AllowedValues>
|
||||
</LiteralData>
|
||||
</Input>
|
||||
<Input minOccurs="0" maxOccurs="1">
|
||||
<ows:Identifier>number_of_runs</ows:Identifier><!-- 3 -->
|
||||
<ows:Title>number of runs</ows:Title>
|
||||
<ows:Abstract>Specifies the number of directions in which the expansion and shrinking will take place. TWO_WAY — Performs expansion and shrinking according to sorting type, then performs an additional shrinking and expansion with the priority reversed. This is the default. ONE_WAY — Performs expansion and shrinking once, according to sorting type.
|
||||
</ows:Abstract>
|
||||
<LiteralData>
|
||||
<ows:DataType ows:reference="xs:boolean"></ows:DataType>
|
||||
<ows:AnyValue/>
|
||||
</LiteralData>
|
||||
</Input>
|
||||
</DataInputs>
|
||||
<ProcessOutputs>
|
||||
<Output>
|
||||
<ows:Identifier>out_raster</ows:Identifier><!-- 1 -->
|
||||
<ows:Title>out raster</ows:Title>
|
||||
<ows:Abstract>The raster to be created.</ows:Abstract>
|
||||
<ComplexOutput>
|
||||
<Default>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Default>
|
||||
<Supported>
|
||||
<Format>
|
||||
<MimeType>application/GeoTIFF</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Supported>
|
||||
</ComplexOutput>
|
||||
</Output>
|
||||
</ProcessOutputs>
|
||||
</ProcessDescription>
|
||||
</wps:ProcessDescriptions>
|
||||
|
||||
|
||||
@ -1,79 +0,0 @@
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<wps:ProcessDescriptions xmlns:wps="http://www.opengis.net/wps/1.0.0" xmlns:ows="http://www.opengis.net/ows/1.1" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.opengis.net/wps/1.0.0
|
||||
http://schemas.opengis.net/wps/1.0.0/wpsDescribeProcess_response.xsd" xml:lang="en-US" service="WPS" version="1.0.0">
|
||||
<ProcessDescription wps:processVersion="2" statusSupported="true" storeSupported="true">
|
||||
<ows:Identifier>org.n52.wps.ags.spatialanalyst.generalization.expand</ows:Identifier><!-- ParameterCount=4 -->
|
||||
<ows:Title>Expand_sa</ows:Title>
|
||||
<ows:Abstract>Expands specified zones of a raster by a specified number of cells. Uses ArcObjects library - Spatial Analyst</ows:Abstract>
|
||||
<DataInputs>
|
||||
<Input minOccurs="1" maxOccurs="1">
|
||||
<ows:Identifier>in_raster</ows:Identifier><!-- 0 -->
|
||||
<ows:Title>in raster</ows:Title>
|
||||
<ows:Abstract>The input raster whose zones are expanded. It must be of integer type.</ows:Abstract>
|
||||
<ComplexData>
|
||||
<Default>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Default>
|
||||
<Supported>
|
||||
<Format>
|
||||
<MimeType>application/GeoTIFF</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Supported>
|
||||
</ComplexData>
|
||||
</Input>
|
||||
<Input minOccurs="1" maxOccurs="1">
|
||||
<ows:Identifier>number_cells</ows:Identifier><!-- 2 -->
|
||||
<ows:Title>number cells</ows:Title>
|
||||
<ows:Abstract>The number of cells to expand each specified zone by.</ows:Abstract>
|
||||
<LiteralData>
|
||||
<ows:DataType ows:reference="xs:integer"></ows:DataType>
|
||||
<ows:AnyValue/>
|
||||
</LiteralData>
|
||||
</Input>
|
||||
<Input minOccurs="2" maxOccurs="1000">
|
||||
<ows:Identifier>zone_values</ows:Identifier><!-- 3 -->
|
||||
<ows:Title>zone values</ows:Title>
|
||||
<ows:Abstract>The list of zone values to expand.</ows:Abstract>
|
||||
<LiteralData>
|
||||
<ows:DataType ows:reference="xs:integer"></ows:DataType>
|
||||
<ows:AnyValue/>
|
||||
</LiteralData>
|
||||
</Input>
|
||||
</DataInputs>
|
||||
<ProcessOutputs>
|
||||
<Output>
|
||||
<ows:Identifier>out_raster</ows:Identifier><!-- 1 -->
|
||||
<ows:Title>out raster</ows:Title>
|
||||
<ows:Abstract>The raster to be created.</ows:Abstract>
|
||||
<ComplexOutput>
|
||||
<Default>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Default>
|
||||
<Supported>
|
||||
<Format>
|
||||
<MimeType>application/GeoTIFF</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Supported>
|
||||
</ComplexOutput>
|
||||
</Output>
|
||||
</ProcessOutputs>
|
||||
</ProcessDescription>
|
||||
</wps:ProcessDescriptions>
|
||||
|
||||
|
||||
@ -1,87 +0,0 @@
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<wps:ProcessDescriptions xmlns:wps="http://www.opengis.net/wps/1.0.0" xmlns:ows="http://www.opengis.net/ows/1.1" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.opengis.net/wps/1.0.0
|
||||
http://schemas.opengis.net/wps/1.0.0/wpsDescribeProcess_response.xsd" xml:lang="en-US" service="WPS" version="1.0.0">
|
||||
<ProcessDescription wps:processVersion="2" statusSupported="true" storeSupported="true">
|
||||
<ows:Identifier>org.n52.wps.ags.spatialanalyst.math.generalization.majorityfilter</ows:Identifier><!-- ParameterCount=4 -->
|
||||
<ows:Title>MajorityFilter_sa</ows:Title>
|
||||
<ows:Abstract>Replaces cells in a raster based on the majority of their contiguous neighboring cells. Uses ArcObjects library - Spatial Analyst</ows:Abstract>
|
||||
<DataInputs>
|
||||
<Input minOccurs="1" maxOccurs="1">
|
||||
<ows:Identifier>in_raster</ows:Identifier><!-- 0 -->
|
||||
<ows:Title>in raster</ows:Title>
|
||||
<ows:Abstract>The input raster that Majority Filter will be applied to. It must be of integer type.</ows:Abstract>
|
||||
<ComplexData>
|
||||
<Default>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Default>
|
||||
<Supported>
|
||||
<Format>
|
||||
<MimeType>application/GeoTIFF</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Supported>
|
||||
</ComplexData>
|
||||
</Input>
|
||||
<Input minOccurs="0" maxOccurs="1">
|
||||
<ows:Identifier>number_neighbors</ows:Identifier><!-- 2 -->
|
||||
<ows:Title>number neighbors</ows:Title>
|
||||
<ows:Abstract>The number of neighboring cells to use in the kernel of the filter. FOUR — The kernel of the filter will be the four direct (orthogonal) neighbors to the present cell. This is the default. EIGHT — The kernel of the filter will be the eight nearest neighbors (a 3 by 3 window) to the present cell.
|
||||
</ows:Abstract>
|
||||
<LiteralData>
|
||||
<ows:DataType ows:reference="xs:string"></ows:DataType>
|
||||
<ows:AllowedValues>
|
||||
<ows:Value>FOUR</ows:Value>
|
||||
<ows:Value>EIGHT</ows:Value>
|
||||
</ows:AllowedValues>
|
||||
</LiteralData>
|
||||
</Input>
|
||||
<Input minOccurs="0" maxOccurs="1">
|
||||
<ows:Identifier>majority_definition</ows:Identifier><!-- 3 -->
|
||||
<ows:Title>majority definition</ows:Title>
|
||||
<ows:Abstract>The number of contiguous (spatially connected) cells that must be of the same value before a replacement will occur. MAJORITY — A majority of cells must have the same value and be contiguous. Three out of four or five out of eight connected cells must have the same value. HALF — Half of the cells must have the same value and be contiguous. Two out of four or four out of eight connected cells must have the same value. Using the Half setting will have a more smoothing effect.
|
||||
</ows:Abstract>
|
||||
<LiteralData>
|
||||
<ows:DataType ows:reference="xs:string"></ows:DataType>
|
||||
<ows:AllowedValues>
|
||||
<ows:Value>MAJORITY</ows:Value>
|
||||
<ows:Value>HALF</ows:Value>
|
||||
</ows:AllowedValues>
|
||||
</LiteralData>
|
||||
</Input>
|
||||
</DataInputs>
|
||||
<ProcessOutputs>
|
||||
<Output>
|
||||
<ows:Identifier>out_raster</ows:Identifier><!-- 1 -->
|
||||
<ows:Title>out raster</ows:Title>
|
||||
<ows:Abstract>The raster to be created.</ows:Abstract>
|
||||
<ComplexOutput>
|
||||
<Default>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Default>
|
||||
<Supported>
|
||||
<Format>
|
||||
<MimeType>application/GeoTIFF</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Supported>
|
||||
</ComplexOutput>
|
||||
</Output>
|
||||
</ProcessOutputs>
|
||||
</ProcessDescription>
|
||||
</wps:ProcessDescriptions>
|
||||
|
||||
|
||||
@ -1,94 +0,0 @@
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<wps:ProcessDescriptions xmlns:wps="http://www.opengis.net/wps/1.0.0" xmlns:ows="http://www.opengis.net/ows/1.1" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.opengis.net/wps/1.0.0
|
||||
http://schemas.opengis.net/wps/1.0.0/wpsDescribeProcess_response.xsd" xml:lang="en-US" service="WPS" version="1.0.0">
|
||||
<ProcessDescription wps:processVersion="2" statusSupported="true" storeSupported="true">
|
||||
<ows:Identifier>org.n52.wps.ags.spatialanalyst.math.generalization.nibble</ows:Identifier><!-- ParameterCount=4 -->
|
||||
<ows:Title>Nibble_sa</ows:Title>
|
||||
<ows:Abstract>Replaces cells of raster corresponding to a mask with the values of the nearest neighbors. Uses ArcObjects library - Spatial Analyst</ows:Abstract>
|
||||
<DataInputs>
|
||||
<Input minOccurs="1" maxOccurs="1">
|
||||
<ows:Identifier>in_raster</ows:Identifier><!-- 0 -->
|
||||
<ows:Title>in raster</ows:Title>
|
||||
<ows:Abstract>The input raster that Nibble will be applied to. It must be of integer type.</ows:Abstract>
|
||||
<ComplexData>
|
||||
<Default>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Default>
|
||||
<Supported>
|
||||
<Format>
|
||||
<MimeType>application/GeoTIFF</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Supported>
|
||||
</ComplexData>
|
||||
</Input>
|
||||
<Input minOccurs="1" maxOccurs="1">
|
||||
<ows:Identifier>in_mask_raster</ows:Identifier><!-- 1 -->
|
||||
<ows:Title>in mask raster</ows:Title>
|
||||
<ows:Abstract>The raster used as the mask. Cells with NoData as their value will be nibbled in the in_raster.</ows:Abstract>
|
||||
<ComplexData>
|
||||
<Default>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Default>
|
||||
<Supported>
|
||||
<Format>
|
||||
<MimeType>application/GeoTIFF</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Supported>
|
||||
</ComplexData>
|
||||
</Input>
|
||||
<Input minOccurs="0" maxOccurs="1">
|
||||
<ows:Identifier>nibble_values</ows:Identifier><!-- 3 -->
|
||||
<ows:Title>nibble values</ows:Title>
|
||||
<ows:Abstract>Keywords defining if NoData values in the in_raster are allowed to nibble into the area defined by the in_mask_raster. ALL — Specifies that the nearest neighbor value will be used whether it is NoData or another data value in the in_raster. NoData values in the in_raster are free to nibble into areas defined in the in_mask_raster if they are the nearest neighbor. DATAONLY — Specifies that only data values are free to nibble into areas defined in the in_mask_raster. NoData values in the in_raster are not allowed to nibble into areas defined in the in_mask_raster even if they are the nearest neighbor.
|
||||
</ows:Abstract>
|
||||
<LiteralData>
|
||||
<ows:DataType ows:reference="xs:boolean"></ows:DataType>
|
||||
<ows:AnyValue/>
|
||||
</LiteralData>
|
||||
</Input>
|
||||
</DataInputs>
|
||||
<ProcessOutputs>
|
||||
<Output>
|
||||
<ows:Identifier>out_raster</ows:Identifier><!-- 2 -->
|
||||
<ows:Title>out raster</ows:Title>
|
||||
<ows:Abstract>The raster to be created.</ows:Abstract>
|
||||
<ComplexOutput>
|
||||
<Default>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Default>
|
||||
<Supported>
|
||||
<Format>
|
||||
<MimeType>application/GeoTIFF</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Supported>
|
||||
</ComplexOutput>
|
||||
</Output>
|
||||
</ProcessOutputs>
|
||||
</ProcessDescription>
|
||||
</wps:ProcessDescriptions>
|
||||
|
||||
|
||||
@ -1,104 +0,0 @@
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<wps:ProcessDescriptions xmlns:wps="http://www.opengis.net/wps/1.0.0" xmlns:ows="http://www.opengis.net/ows/1.1" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.opengis.net/wps/1.0.0
|
||||
http://schemas.opengis.net/wps/1.0.0/wpsDescribeProcess_response.xsd" xml:lang="en-US" service="WPS" version="1.0.0">
|
||||
<ProcessDescription wps:processVersion="2" statusSupported="true" storeSupported="true">
|
||||
<ows:Identifier>org.n52.wps.ags.spatialanalyst.math.generalization.regiongroup</ows:Identifier><!-- ParameterCount=6 -->
|
||||
<ows:Title>RegionGroup_sa</ows:Title>
|
||||
<ows:Abstract>For each cell in the output, Regiongroup records the identify of the connected region to which that cell belongs.A unique number is assigned to each region. Uses ArcObjects library - Spatial Analyst</ows:Abstract>
|
||||
<DataInputs>
|
||||
<Input minOccurs="1" maxOccurs="1">
|
||||
<ows:Identifier>in_raster</ows:Identifier><!-- 0 -->
|
||||
<ows:Title>in raster</ows:Title>
|
||||
<ows:Abstract>The input raster that Region Group will be applied to. It must be of integer type.</ows:Abstract>
|
||||
<ComplexData>
|
||||
<Default>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Default>
|
||||
<Supported>
|
||||
<Format>
|
||||
<MimeType>application/GeoTIFF</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Supported>
|
||||
</ComplexData>
|
||||
</Input>
|
||||
<Input minOccurs="0" maxOccurs="1">
|
||||
<ows:Identifier>number_neighbors</ows:Identifier><!-- 2 -->
|
||||
<ows:Title>number neighbors</ows:Title>
|
||||
<ows:Abstract>The number of neighboring cells to use in evaluating connectivity between cells. FOUR — Defines connectivity between cells of the same value only if the cells are directly to the right or left or above or below each other — the four nearest neighbors. If two cells with the same value are diagonal from one another, they are not considered connected. EIGHT — Defines connectivity between cells of the same value if they are within the immediate eight-cell neighborhood (eight nearest neighbors) of each other. This includes to the right or left, above or below, or diagonal to each other.
|
||||
</ows:Abstract>
|
||||
<LiteralData>
|
||||
<ows:DataType ows:reference="xs:string"></ows:DataType>
|
||||
<ows:AllowedValues>
|
||||
<ows:Value>FOUR</ows:Value>
|
||||
<ows:Value>EIGHT</ows:Value>
|
||||
</ows:AllowedValues>
|
||||
</LiteralData>
|
||||
</Input>
|
||||
<Input minOccurs="0" maxOccurs="1">
|
||||
<ows:Identifier>zone_connectivity</ows:Identifier><!-- 3 -->
|
||||
<ows:Title>zone connectivity</ows:Title>
|
||||
<ows:Abstract>Defines which cell values should be considered when testing for connectivity. WITHIN — Tests connectivity between input values that are the same within the same zone. The only cells that can be grouped are cells from the same zone (value) that meet the spatial requirements of connectivity specified by the FOUR and EIGHT keywords. CROSS — Tests connectivity by the spatial requirements specified by the keywords FOUR or EIGHT between cells with any values except the excluded value identified by the argument {excluded_value} if one is specified. A value for the {excluded_value} argument must be input when CROSS is used.</ows:Abstract>
|
||||
<LiteralData>
|
||||
<ows:DataType ows:reference="xs:string"></ows:DataType>
|
||||
<ows:AllowedValues>
|
||||
<ows:Value>WITHIN</ows:Value>
|
||||
<ows:Value>CROSS</ows:Value>
|
||||
</ows:AllowedValues>
|
||||
</LiteralData>
|
||||
</Input>
|
||||
<Input minOccurs="0" maxOccurs="1">
|
||||
<ows:Identifier>add_link</ows:Identifier><!-- 4 -->
|
||||
<ows:Title>add link</ows:Title>
|
||||
<ows:Abstract>Specifies whether a link field is added to the table of the output. ADD_LINK — An ADD_LINK item will be added to the table of the output raster. The ADD_LINK item stores the original values for each newly created zone, from disconnected regions, from the input raster before they are regrouped. NO_LINK — The attribute table for the output grid will only contain the Value and Count items.</ows:Abstract>
|
||||
<LiteralData>
|
||||
<ows:DataType ows:reference="xs:boolean"></ows:DataType>
|
||||
<ows:AnyValue/>
|
||||
</LiteralData>
|
||||
</Input>
|
||||
<Input minOccurs="0" maxOccurs="1">
|
||||
<ows:Identifier>excluded_value</ows:Identifier><!-- 5 -->
|
||||
<ows:Title>excluded value</ows:Title>
|
||||
<ows:Abstract>Identifies a value such that if a cell location contains the value, no spatial connectivity will be evaluated regardless of the keyword specified (FOUR or EIGHT). Cells with the excluded value will be treated as NoData and are eliminated from calculations. Cell locations that contain an excluded value will receive zero for the location on the output raster. The excluded value is similar to the concept of a background value or setting a mask for a single function on the Environment Settings/Raster Settings dialog box. It is particularly useful in conjunction with the CROSS keyword and must be specified if the CROSS keyword is specified.</ows:Abstract>
|
||||
<LiteralData>
|
||||
<ows:DataType ows:reference="xs:double"></ows:DataType>
|
||||
<ows:AnyValue/>
|
||||
</LiteralData>
|
||||
</Input>
|
||||
</DataInputs>
|
||||
<ProcessOutputs>
|
||||
<Output>
|
||||
<ows:Identifier>out_raster</ows:Identifier><!-- 1 -->
|
||||
<ows:Title>out raster</ows:Title>
|
||||
<ows:Abstract>The raster to be created.</ows:Abstract>
|
||||
<ComplexOutput>
|
||||
<Default>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Default>
|
||||
<Supported>
|
||||
<Format>
|
||||
<MimeType>application/GeoTIFF</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Supported>
|
||||
</ComplexOutput>
|
||||
</Output>
|
||||
</ProcessOutputs>
|
||||
</ProcessDescription>
|
||||
</wps:ProcessDescriptions>
|
||||
|
||||
|
||||
@ -1,79 +0,0 @@
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<wps:ProcessDescriptions xmlns:wps="http://www.opengis.net/wps/1.0.0" xmlns:ows="http://www.opengis.net/ows/1.1" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.opengis.net/wps/1.0.0
|
||||
http://schemas.opengis.net/wps/1.0.0/wpsDescribeProcess_response.xsd" xml:lang="en-US" service="WPS" version="1.0.0">
|
||||
<ProcessDescription wps:processVersion="2" statusSupported="true" storeSupported="true">
|
||||
<ows:Identifier>org.n52.wps.ags.spatialanalyst.generalization.shrink</ows:Identifier><!-- ParameterCount=4 -->
|
||||
<ows:Title>Shrink_sa</ows:Title>
|
||||
<ows:Abstract>Shrinks the selected zones by a specified number of cells. Uses ArcObjects library - Spatial Analyst</ows:Abstract>
|
||||
<DataInputs>
|
||||
<Input minOccurs="1" maxOccurs="1">
|
||||
<ows:Identifier>in_raster</ows:Identifier><!-- 0 -->
|
||||
<ows:Title>in raster</ows:Title>
|
||||
<ows:Abstract>The input raster that Shrink will be applied to. It must be of integer type.</ows:Abstract>
|
||||
<ComplexData>
|
||||
<Default>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Default>
|
||||
<Supported>
|
||||
<Format>
|
||||
<MimeType>application/GeoTIFF</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Supported>
|
||||
</ComplexData>
|
||||
</Input>
|
||||
<Input minOccurs="1" maxOccurs="1">
|
||||
<ows:Identifier>number_cells</ows:Identifier><!-- 2 -->
|
||||
<ows:Title>number cells</ows:Title>
|
||||
<ows:Abstract>The number of cells by which to shrink each specified zone.</ows:Abstract>
|
||||
<LiteralData>
|
||||
<ows:DataType ows:reference="xs:long"></ows:DataType>
|
||||
<ows:AnyValue/>
|
||||
</LiteralData>
|
||||
</Input>
|
||||
<Input minOccurs="2" maxOccurs="1000"><!-- 3 -->
|
||||
<ows:Identifier>zone_values</ows:Identifier>
|
||||
<ows:Title>zone values</ows:Title>
|
||||
<ows:Abstract>List of zone values to shrink.</ows:Abstract>
|
||||
<LiteralData>
|
||||
<ows:DataType ows:reference="xs:long"></ows:DataType>
|
||||
<ows:AnyValue/>
|
||||
</LiteralData>
|
||||
</Input>
|
||||
</DataInputs>
|
||||
<ProcessOutputs>
|
||||
<Output>
|
||||
<ows:Identifier>out_raster</ows:Identifier><!-- 1 -->
|
||||
<ows:Title>out raster</ows:Title>
|
||||
<ows:Abstract>The raster to be created.</ows:Abstract>
|
||||
<ComplexOutput>
|
||||
<Default>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Default>
|
||||
<Supported>
|
||||
<Format>
|
||||
<MimeType>application/GeoTIFF</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Supported>
|
||||
</ComplexOutput>
|
||||
</Output>
|
||||
</ProcessOutputs>
|
||||
</ProcessDescription>
|
||||
</wps:ProcessDescriptions>
|
||||
|
||||
|
||||
@ -1,105 +0,0 @@
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<wps:ProcessDescriptions xmlns:wps="http://www.opengis.net/wps/1.0.0" xmlns:ows="http://www.opengis.net/ows/1.1" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.opengis.net/wps/1.0.0
|
||||
http://schemas.opengis.net/wps/1.0.0/wpsDescribeProcess_response.xsd" xml:lang="en-US" service="WPS" version="1.0.0">
|
||||
<ProcessDescription wps:processVersion="2" statusSupported="true" storeSupported="true">
|
||||
<ows:Identifier>org.n52.wps.ags.spatialanalyst.generalization.thin</ows:Identifier><!-- ParameterCount=6 -->
|
||||
<ows:Title>Thin_sa</ows:Title>
|
||||
<ows:Abstract>Thins rasterized linear features by reducing the number of cells representing the width of the features. Uses ArcObjects library - Spatial Analyst</ows:Abstract>
|
||||
<DataInputs>
|
||||
<Input minOccurs="1" maxOccurs="1">
|
||||
<ows:Identifier>in_raster</ows:Identifier><!-- 0 -->
|
||||
<ows:Title>in raster</ows:Title>
|
||||
<ows:Abstract>The input raster that Thin will be applied to. It must be of integer type.</ows:Abstract>
|
||||
<ComplexData>
|
||||
<Default>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Default>
|
||||
<Supported>
|
||||
<Format>
|
||||
<MimeType>application/GeoTIFF</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Supported>
|
||||
</ComplexData>
|
||||
</Input>
|
||||
<Input minOccurs="0" maxOccurs="1">
|
||||
<ows:Identifier>background_value</ows:Identifier><!-- 2 -->
|
||||
<ows:Title>background value</ows:Title>
|
||||
<ows:Abstract>Specifies the cell value that will identify the background cells. The linear features are formed from the foreground cells. ZERO — The background is composed of cells of zero or less, or NoData. All cells whose value is greater than zero are the foreground. NODATA — The background is composed of NoData cells. All cells with valid values belong to the foreground.
|
||||
</ows:Abstract>
|
||||
<LiteralData>
|
||||
<ows:DataType ows:reference="xs:string"></ows:DataType>
|
||||
<ows:AllowedValues>
|
||||
<ows:Value>ZERO</ows:Value>
|
||||
<ows:Value>NODATA</ows:Value>
|
||||
</ows:AllowedValues>
|
||||
</LiteralData>
|
||||
</Input>
|
||||
<Input minOccurs="0" maxOccurs="1">
|
||||
<ows:Identifier>filter</ows:Identifier><!-- 3 -->
|
||||
<ows:Title>filter</ows:Title>
|
||||
<ows:Abstract>Specifies whether a filter will be applied as the first phase of thinning. NOFILTER — No filter will be applied. FILTER — The raster will be filtered to smooth the boundaries between foreground and background cells. This option will eliminate minor irregularities from the output raster.
|
||||
</ows:Abstract>
|
||||
<LiteralData>
|
||||
<ows:DataType ows:reference="xs:boolean"></ows:DataType>
|
||||
<ows:AnyValue/>
|
||||
</LiteralData>
|
||||
</Input>
|
||||
<Input minOccurs="0" maxOccurs="1">
|
||||
<ows:Identifier>corners</ows:Identifier><!-- 4 -->
|
||||
<ows:Title>corners</ows:Title>
|
||||
<ows:Abstract>Specifies whether round or sharp turns will be made at turns or junctions. It is also used during the vector conversion process to spline curves or create sharp intersections and corners. ROUND — Attempts to smooth corners and junctions. This is best for vectorizing natural features, such as contours or streams. SHARP — Attempts to preserve rectangular corners and junctions. This is best for vectorizing manmade features, such as streets.</ows:Abstract>
|
||||
<LiteralData>
|
||||
<ows:DataType ows:reference="xs:string"></ows:DataType>
|
||||
<ows:AllowedValues>
|
||||
<ows:Value>ROUND</ows:Value>
|
||||
<ows:Value>SHARP</ows:Value>
|
||||
</ows:AllowedValues>
|
||||
</LiteralData>
|
||||
</Input>
|
||||
<Input minOccurs="0" maxOccurs="1">
|
||||
<ows:Identifier>maximum_thickness</ows:Identifier><!-- 5 -->
|
||||
<ows:Title>maximum thickness</ows:Title>
|
||||
<ows:Abstract>The maximum thickness, in map units, of linear features in the input grid. The default thickness is ten times the cell size.</ows:Abstract>
|
||||
<LiteralData>
|
||||
<ows:DataType ows:reference="xs:integer"></ows:DataType>
|
||||
<ows:AnyValue/>
|
||||
</LiteralData>
|
||||
</Input>
|
||||
</DataInputs>
|
||||
<ProcessOutputs>
|
||||
<Output>
|
||||
<ows:Identifier>out_raster</ows:Identifier><!-- 1 -->
|
||||
<ows:Title>out raster</ows:Title>
|
||||
<ows:Abstract>The raster to be created.</ows:Abstract>
|
||||
<ComplexOutput>
|
||||
<Default>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Default>
|
||||
<Supported>
|
||||
<Format>
|
||||
<MimeType>application/GeoTIFF</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Supported>
|
||||
</ComplexOutput>
|
||||
</Output>
|
||||
</ProcessOutputs>
|
||||
</ProcessDescription>
|
||||
</wps:ProcessDescriptions>
|
||||
|
||||
|
||||
@ -1,176 +0,0 @@
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<wps:ProcessDescriptions xmlns:wps="http://www.opengis.net/wps/1.0.0" xmlns:ows="http://www.opengis.net/ows/1.1" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.opengis.net/wps/1.0.0
|
||||
http://schemas.opengis.net/wps/1.0.0/wpsDescribeProcess_response.xsd" xml:lang="en-US" service="WPS" version="1.0.0">
|
||||
<ProcessDescription wps:processVersion="2" statusSupported="true" storeSupported="true">
|
||||
<ows:Identifier>org.n52.wps.ags.spatialanalyst.groundwater.darcyflow</ows:Identifier><!-- ParameterCount=7 -->
|
||||
<ows:Title>DarcyFlow_sa</ows:Title>
|
||||
<ows:Abstract>Calculates the groundwater volume balance residual and other outputs for steady flow in an aquifer. Uses ArcObjects library - Spatial Analyst</ows:Abstract>
|
||||
<DataInputs>
|
||||
<Input minOccurs="1" maxOccurs="1">
|
||||
<ows:Identifier>in_head_raster</ows:Identifier><!-- 0 -->
|
||||
<ows:Title>in head raster</ows:Title>
|
||||
<ows:Abstract>The input raster where each cell value represents the groundwater head elevation at that location. The head is typically an elevation above some datum, such as mean sea level.</ows:Abstract>
|
||||
<ComplexData>
|
||||
<Default>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Default>
|
||||
<Supported>
|
||||
<Format>
|
||||
<MimeType>application/GeoTIFF</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Supported>
|
||||
</ComplexData>
|
||||
</Input>
|
||||
<Input minOccurs="1" maxOccurs="1">
|
||||
<ows:Identifier>in_porosity_raster</ows:Identifier><!-- 1 -->
|
||||
<ows:Title>in porosity raster</ows:Title>
|
||||
<ows:Abstract>The input raster where each cell value represents the effective formation porosity at that location.</ows:Abstract>
|
||||
<ComplexData>
|
||||
<Default>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Default>
|
||||
<Supported>
|
||||
<Format>
|
||||
<MimeType>application/GeoTIFF</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Supported>
|
||||
</ComplexData>
|
||||
</Input>
|
||||
<Input minOccurs="1" maxOccurs="1">
|
||||
<ows:Identifier>in_thickness_raster</ows:Identifier><!-- 2 -->
|
||||
<ows:Title>in thickness raster</ows:Title>
|
||||
<ows:Abstract>The input raster where each cell value represents the saturated thickness at that location. The value for the thickness is interpreted from geological properties of the aquifer.</ows:Abstract>
|
||||
<ComplexData>
|
||||
<Default>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Default>
|
||||
<Supported>
|
||||
<Format>
|
||||
<MimeType>application/GeoTIFF</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Supported>
|
||||
</ComplexData>
|
||||
</Input>
|
||||
<Input minOccurs="1" maxOccurs="1">
|
||||
<ows:Identifier>in_transmissivity_raster</ows:Identifier><!-- 3 -->
|
||||
<ows:Title>in transmissivity raster</ows:Title>
|
||||
<ows:Abstract>The input raster where each cell value represents the formation transmissivity at that location. The transmissivity of an aquifer is defined as the hydraulic conductivity K times the saturated aquifer thickness b, as units of length squared over time. This property is generally estimated from field experimental data such as pumping tests. Tables 1 and 2 in How Darcy Flow and Darcy Velocity work list ranges of hydraulic conductivities for some generalized geologic materials.</ows:Abstract>
|
||||
<ComplexData>
|
||||
<Default>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Default>
|
||||
<Supported>
|
||||
<Format>
|
||||
<MimeType>application/GeoTIFF</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Supported>
|
||||
</ComplexData>
|
||||
</Input>
|
||||
</DataInputs>
|
||||
<ProcessOutputs>
|
||||
<Output>
|
||||
<ows:Identifier>out_volume_raster</ows:Identifier><!-- 4 -->
|
||||
<ows:Title>out volume raster</ows:Title>
|
||||
<ows:Abstract>The output raster where each cell value represents the groundwater volume balance residual for steady flow in an aquifer, as determined by Darcy's Law.</ows:Abstract>
|
||||
<ComplexOutput>
|
||||
<Default>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Default>
|
||||
<Supported>
|
||||
<Format>
|
||||
<MimeType>application/GeoTIFF</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Supported>
|
||||
</ComplexOutput>
|
||||
</Output>
|
||||
<Output>
|
||||
<ows:Identifier>out_direction_raster</ows:Identifier><!-- 5 -->
|
||||
<ows:Title>out direction raster</ows:Title>
|
||||
<ows:Abstract>An optional output raster where each cell value represents the direction of the seepage velocity vector (average linear velocity) at the center of the cell, calculated as the average value of the seepage velocity through the four faces of the cell. It is used with the {out_magnitude_raster} to describe the flow vector.</ows:Abstract>
|
||||
<ComplexOutput>
|
||||
<Default>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Default>
|
||||
<Supported>
|
||||
<Format>
|
||||
<MimeType>application/GeoTIFF</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Supported>
|
||||
</ComplexOutput>
|
||||
</Output>
|
||||
<Output>
|
||||
<ows:Identifier>out_magnitude_raster</ows:Identifier><!-- 6 -->
|
||||
<ows:Title>out magnitude raster</ows:Title>
|
||||
<ows:Abstract>An optional output raster where each cell value represents the magnitude of the seepage velocity vector (average linear velocity) at the center of the cell, calculated as the average value of the seepage velocity through the four faces of the cell. It is used with the {out_direction_raster} to describe the flow vector.</ows:Abstract>
|
||||
<ComplexOutput>
|
||||
<Default>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Default>
|
||||
<Supported>
|
||||
<Format>
|
||||
<MimeType>application/GeoTIFF</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Supported>
|
||||
</ComplexOutput>
|
||||
</Output>
|
||||
</ProcessOutputs>
|
||||
</ProcessDescription>
|
||||
</wps:ProcessDescriptions>
|
||||
|
||||
|
||||
@ -1,153 +0,0 @@
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<wps:ProcessDescriptions xmlns:wps="http://www.opengis.net/wps/1.0.0" xmlns:ows="http://www.opengis.net/ows/1.1" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.opengis.net/wps/1.0.0
|
||||
http://schemas.opengis.net/wps/1.0.0/wpsDescribeProcess_response.xsd" xml:lang="en-US" service="WPS" version="1.0.0">
|
||||
<ProcessDescription wps:processVersion="2" statusSupported="true" storeSupported="true">
|
||||
<ows:Identifier>org.n52.wps.ags.spatialanalyst.groundwater.darcyvelocity</ows:Identifier><!-- ParameterCount=6 -->
|
||||
<ows:Title>DarcyVelocity_sa</ows:Title>
|
||||
<ows:Abstract>Calculates the groundwater seepage velocity vector (direction and magnitude) for steady flow in an aquifer. Uses ArcObjects library - Spatial Analyst</ows:Abstract>
|
||||
<DataInputs>
|
||||
<Input minOccurs="1" maxOccurs="1">
|
||||
<ows:Identifier>in_head_raster</ows:Identifier><!-- 0 -->
|
||||
<ows:Title>in head raster</ows:Title>
|
||||
<ows:Abstract>The input raster where each cell value represents the groundwater head elevation at that location. The head is typically an elevation above some datum, such as mean sea level.</ows:Abstract>
|
||||
<ComplexData>
|
||||
<Default>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Default>
|
||||
<Supported>
|
||||
<Format>
|
||||
<MimeType>application/GeoTIFF</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Supported>
|
||||
</ComplexData>
|
||||
</Input>
|
||||
<Input minOccurs="1" maxOccurs="1">
|
||||
<ows:Identifier>in_porosity_raster</ows:Identifier><!-- 1 -->
|
||||
<ows:Title>in porosity raster</ows:Title>
|
||||
<ows:Abstract>The input raster where each cell value represents the effective formation porosity at that location.</ows:Abstract>
|
||||
<ComplexData>
|
||||
<Default>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Default>
|
||||
<Supported>
|
||||
<Format>
|
||||
<MimeType>application/GeoTIFF</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Supported>
|
||||
</ComplexData>
|
||||
</Input>
|
||||
<Input minOccurs="1" maxOccurs="1">
|
||||
<ows:Identifier>in_thickness_raster</ows:Identifier><!-- 2 -->
|
||||
<ows:Title>in thickness raster</ows:Title>
|
||||
<ows:Abstract>The input raster where each cell value represents the saturated thickness at that location. The value for the thickness is interpreted from geological properties of the aquifer.</ows:Abstract>
|
||||
<ComplexData>
|
||||
<Default>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Default>
|
||||
<Supported>
|
||||
<Format>
|
||||
<MimeType>application/GeoTIFF</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Supported>
|
||||
</ComplexData>
|
||||
</Input>
|
||||
<Input minOccurs="1" maxOccurs="1">
|
||||
<ows:Identifier>in_transmissivity_raster</ows:Identifier><!-- 3 -->
|
||||
<ows:Title>in transmissivity raster</ows:Title>
|
||||
<ows:Abstract>The input raster where each cell value represents the formation transmissivity at that location. The transmissivity of an aquifer is defined as the hydraulic conductivity K times the saturated aquifer thickness b, as units of length squared over time. This property is generally estimated from field experimental data, such as pumping tests. Tables 1 and 2 in How Darcy Flow and Darcy Velocity work list ranges of hydraulic conductivities for some generalized geologic materials.</ows:Abstract>
|
||||
<ComplexData>
|
||||
<Default>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Default>
|
||||
<Supported>
|
||||
<Format>
|
||||
<MimeType>application/GeoTIFF</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Supported>
|
||||
</ComplexData>
|
||||
</Input>
|
||||
</DataInputs>
|
||||
<ProcessOutputs>
|
||||
<Output>
|
||||
<ows:Identifier>out_direction_raster</ows:Identifier><!-- 4 -->
|
||||
<ows:Title>out direction raster</ows:Title>
|
||||
<ows:Abstract>The output raster where each cell value represents the direction of the seepage velocity vector (average linear velocity) at the center of the cell, calculated as the average value of the seepage velocity through the four faces of the cell. It is used with the out_magnitude_raster to describe the flow vector.</ows:Abstract>
|
||||
<ComplexOutput>
|
||||
<Default>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Default>
|
||||
<Supported>
|
||||
<Format>
|
||||
<MimeType>application/GeoTIFF</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Supported>
|
||||
</ComplexOutput>
|
||||
</Output>
|
||||
<Output>
|
||||
<ows:Identifier>out_magnitude_raster</ows:Identifier><!-- 5 -->
|
||||
<ows:Title>out magnitude raster</ows:Title>
|
||||
<ows:Abstract>The output raster where each cell value represents the magnitude of the seepage velocity vector (average linear velocity) at the center of the cell, calculated as the average value of the seepage velocity through the four faces of the cell. It is used with the out_direction_raster to describe the flow vector.</ows:Abstract>
|
||||
<ComplexOutput>
|
||||
<Default>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Default>
|
||||
<Supported>
|
||||
<Format>
|
||||
<MimeType>application/GeoTIFF</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Supported>
|
||||
</ComplexOutput>
|
||||
</Output>
|
||||
</ProcessOutputs>
|
||||
</ProcessDescription>
|
||||
</wps:ProcessDescriptions>
|
||||
|
||||
|
||||
@ -1,126 +0,0 @@
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<wps:ProcessDescriptions xmlns:wps="http://www.opengis.net/wps/1.0.0" xmlns:ows="http://www.opengis.net/ows/1.1" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.opengis.net/wps/1.0.0
|
||||
http://schemas.opengis.net/wps/1.0.0/wpsDescribeProcess_response.xsd" xml:lang="en-US" service="WPS" version="1.0.0">
|
||||
<ProcessDescription wps:processVersion="2" statusSupported="true" storeSupported="true">
|
||||
<ows:Identifier>org.n52.wps.ags.spatialanalyst.groundwater.particletrack</ows:Identifier><!-- ParameterCount=7 -->
|
||||
<ows:Title>ParticleTrack_sa</ows:Title>
|
||||
<ows:Abstract>Calculates the path of a particle through a velocity field, returning an ASCII file of particle tracking data and, optionally, a coverage of track information. Uses ArcObjects library - Spatial Analyst</ows:Abstract>
|
||||
<DataInputs>
|
||||
<Input minOccurs="1" maxOccurs="1">
|
||||
<ows:Identifier>in_direction_raster</ows:Identifier><!-- 0 -->
|
||||
<ows:Title>input direction raster</ows:Title>
|
||||
<ows:Abstract>Input direction of the velocity raster. Directions are expressed in compass coordinates, in degrees clockwise from north. This can be created by the Darcy Flow function. Direction values must be floating point.</ows:Abstract>
|
||||
<ComplexData>
|
||||
<Default>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Default>
|
||||
<Supported>
|
||||
<Format>
|
||||
<MimeType>application/GeoTIFF</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Supported>
|
||||
</ComplexData>
|
||||
</Input>
|
||||
<Input minOccurs="1" maxOccurs="1">
|
||||
<ows:Identifier>in_magnitude_raster</ows:Identifier><!-- 1 -->
|
||||
<ows:Title>input magnitude raster</ows:Title>
|
||||
<ows:Abstract>An input raster where each cell value represents the magnitude of the seepage velocity vector (average linear velocity) at the center of the cell. Units are length/time. This can be created by the Darcy Flow function.</ows:Abstract>
|
||||
<ComplexData>
|
||||
<Default>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Default>
|
||||
<Supported>
|
||||
<Format>
|
||||
<MimeType>application/GeoTIFF</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Supported>
|
||||
</ComplexData>
|
||||
</Input>
|
||||
<Input minOccurs="1" maxOccurs="1">
|
||||
<ows:Identifier>source_point</ows:Identifier><!-- 2 -->
|
||||
<ows:Title>source point</ows:Title>
|
||||
<ows:Abstract>The location of the source point from which to begin the particle tracking. This is entered as numbers identifying the x,y coordinates of the position in map units.</ows:Abstract>
|
||||
<LiteralData>
|
||||
<ows:DataType ows:reference="xs:string"></ows:DataType>
|
||||
<ows:AnyValue/>
|
||||
</LiteralData>
|
||||
</Input>
|
||||
<Input minOccurs="0" maxOccurs="1">
|
||||
<ows:Identifier>step length</ows:Identifier><!-- 4 -->
|
||||
<ows:Title>step_length</ows:Title>
|
||||
<ows:Abstract>The step length to be used for calculating the particle track. The default is one half the cell size. Units are length.</ows:Abstract>
|
||||
<LiteralData>
|
||||
<ows:DataType ows:reference="xs:double"></ows:DataType>
|
||||
<ows:AnyValue/>
|
||||
</LiteralData>
|
||||
</Input>
|
||||
<Input minOccurs="0" maxOccurs="1">
|
||||
<ows:Identifier>tracking_time</ows:Identifier><!-- 5 -->
|
||||
<ows:Title>tracking time</ows:Title>
|
||||
<ows:Abstract>Maximum elapsed time for particle tracking. Particle Track will follow the track until either this time is met or the particle migrates off the raster or into a depression. The default value is infinity. Units are time.</ows:Abstract>
|
||||
<LiteralData>
|
||||
<ows:DataType ows:reference="xs:double"></ows:DataType>
|
||||
<ows:AnyValue/>
|
||||
</LiteralData>
|
||||
</Input>
|
||||
</DataInputs>
|
||||
<ProcessOutputs>
|
||||
<Output>
|
||||
<ows:Identifier>out_track_file</ows:Identifier><!-- 3 -->
|
||||
<ows:Title>out track file</ows:Title>
|
||||
<ows:Abstract>The output ASCII text file that contains the particle tracking data.</ows:Abstract>
|
||||
<ComplexOutput>
|
||||
<Default>
|
||||
<Format>
|
||||
<MimeType>application/txt</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Default>
|
||||
<Supported>
|
||||
<Format>
|
||||
<MimeType>application/txt</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Supported>
|
||||
</ComplexOutput>
|
||||
</Output>
|
||||
<Output>
|
||||
<ows:Identifier>out_track_polyline_features</ows:Identifier><!-- 6 -->
|
||||
<ows:Title>out track polyline features</ows:Title>
|
||||
<ows:Abstract>The optional output line feature class containing the particle track. This feature class contains a series of arcs with attributes for position, local velocity direction and magnitude, and cumulative length and time of travel along the path.</ows:Abstract>
|
||||
<ComplexOutput>
|
||||
<Default>
|
||||
<Format>
|
||||
<MimeType>application/x-zipped-shp</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Default>
|
||||
<Supported>
|
||||
<Format>
|
||||
<MimeType>application/x-zipped-shp</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Supported>
|
||||
</ComplexOutput>
|
||||
</Output>
|
||||
</ProcessOutputs>
|
||||
</ProcessDescription>
|
||||
</wps:ProcessDescriptions>
|
||||
|
||||
|
||||
@ -1,157 +0,0 @@
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<wps:ProcessDescriptions xmlns:wps="http://www.opengis.net/wps/1.0.0" xmlns:ows="http://www.opengis.net/ows/1.1" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.opengis.net/wps/1.0.0
|
||||
http://schemas.opengis.net/wps/1.0.0/wpsDescribeProcess_response.xsd" xml:lang="en-US" service="WPS" version="1.0.0">
|
||||
<ProcessDescription wps:processVersion="2" statusSupported="true" storeSupported="true">
|
||||
<ows:Identifier>org.n52.wps.ags.spatialanalyst.groundwater.porouspuff</ows:Identifier><!-- ParameterCount=10 -->
|
||||
<ows:Title>PorousPuff_sa</ows:Title>
|
||||
<ows:Abstract>Calculates the time-dependent, two-dimensional concentration distribution in mass per volume of a solute introduced instantaneously and at a discrete point into a vertically mixed aquifer. Uses ArcObjects library - Spatial Analyst</ows:Abstract>
|
||||
<DataInputs>
|
||||
<Input minOccurs="1" maxOccurs="1">
|
||||
<ows:Identifier>input_track_file</ows:Identifier><!-- 0 -->
|
||||
<ows:Title>input track file</ows:Title>
|
||||
<ows:Abstract>The input particle track path file. This is an ASCII text file containing information about the position, the local velocity vector, and the cumulative length and time of travel along the path. This file is generated using Particle Track.</ows:Abstract>
|
||||
<ComplexData>
|
||||
<Default>
|
||||
<Format>
|
||||
<MimeType>application/txt</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Default>
|
||||
<Supported>
|
||||
<Format>
|
||||
<MimeType>application/txt</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Supported>
|
||||
</ComplexData>
|
||||
</Input>
|
||||
<Input minOccurs="1" maxOccurs="1">
|
||||
<ows:Identifier>in_porosity_raster</ows:Identifier><!-- 1 -->
|
||||
<ows:Title>in porosity raster</ows:Title>
|
||||
<ows:Abstract>The input raster where each cell value represents the effective formation porosity at that location.</ows:Abstract>
|
||||
<ComplexData>
|
||||
<Default>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Default>
|
||||
<Supported>
|
||||
<Format>
|
||||
<MimeType>application/GeoTIFF</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Supported>
|
||||
</ComplexData>
|
||||
</Input>
|
||||
<Input minOccurs="1" maxOccurs="1">
|
||||
<ows:Identifier>in_thickness_raster</ows:Identifier><!-- 2 -->
|
||||
<ows:Title>in thickness raster</ows:Title>
|
||||
<ows:Abstract>The input raster where each cell value represents the saturated thickness at that location. The value for the thickness is interpreted from geological properties of the aquifer.</ows:Abstract>
|
||||
<ComplexData>
|
||||
<Default>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Default>
|
||||
<Supported>
|
||||
<Format>
|
||||
<MimeType>application/GeoTIFF</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Supported>
|
||||
</ComplexData>
|
||||
</Input>
|
||||
<Input minOccurs="1" maxOccurs="1">
|
||||
<ows:Identifier>mass</ows:Identifier><!-- 4 -->
|
||||
<ows:Title>mass</ows:Title>
|
||||
<ows:Abstract>A value for the amount of mass released instantaneously at the source point, in units of mass.</ows:Abstract>
|
||||
<LiteralData>
|
||||
<ows:DataType ows:reference="xs:double"></ows:DataType>
|
||||
<ows:AnyValue/>
|
||||
</LiteralData>
|
||||
</Input>
|
||||
<Input minOccurs="0" maxOccurs="1">
|
||||
<ows:Identifier>desipersion_time</ows:Identifier><!-- 5 -->
|
||||
<ows:Title>dispersion time</ows:Title>
|
||||
<ows:Abstract>A value representing the time horizon for dispersion of the solute, in units of time. The time must be less than or equal to the maximum time in the track file. If the requested time exceeds the available time from the track file, the function is aborted. The default time is the latest time (corresponding to the terminal point) in the track file.</ows:Abstract>
|
||||
<LiteralData>
|
||||
<ows:DataType ows:reference="xs:double"></ows:DataType>
|
||||
<ows:AnyValue/>
|
||||
</LiteralData>
|
||||
</Input>
|
||||
<Input minOccurs="0" maxOccurs="1">
|
||||
<ows:Identifier>longitudinal_dispersivity</ows:Identifier><!-- 6 -->
|
||||
<ows:Title>longitudinal dispersivity</ows:Title>
|
||||
<ows:Abstract>A value representing the dispersivity parallel to the flow direction. For details on how the default value is determined, and how it relates to the scale of the study, see the How Porous Puff works section in the documentation.</ows:Abstract>
|
||||
<LiteralData>
|
||||
<ows:DataType ows:reference="xs:double"></ows:DataType>
|
||||
<ows:AnyValue/>
|
||||
</LiteralData>
|
||||
</Input>
|
||||
<Input minOccurs="0" maxOccurs="1">
|
||||
<ows:Identifier>dispersivity_ratio</ows:Identifier><!-- 7 -->
|
||||
<ows:Title>dispersivity ratio</ows:Title>
|
||||
<ows:Abstract>A value representing the ratio of longitudinal dispersivity over transverse dispersivity. Transverse dispersivity is perpendicular to the flow direction in the same horizontal plane. The default value is three.</ows:Abstract>
|
||||
<LiteralData>
|
||||
<ows:DataType ows:reference="xs:double"></ows:DataType>
|
||||
<ows:AnyValue/>
|
||||
</LiteralData>
|
||||
</Input>
|
||||
<Input minOccurs="0" maxOccurs="1">
|
||||
<ows:Identifier>retardation_factor</ows:Identifier><!-- 8 -->
|
||||
<ows:Title>retardation factor</ows:Title>
|
||||
<ows:Abstract>A dimensionless value representing the retardation of the solute in the aquifer. Retardation varies between one and infinity, with one corresponding to no retardation. The default value is one.</ows:Abstract>
|
||||
<LiteralData>
|
||||
<ows:DataType ows:reference="xs:double"></ows:DataType>
|
||||
<ows:AnyValue/>
|
||||
</LiteralData>
|
||||
</Input>
|
||||
<Input minOccurs="0" maxOccurs="1">
|
||||
<ows:Identifier>decay_coefficient</ows:Identifier><!-- 9 -->
|
||||
<ows:Title>decay coefficient</ows:Title>
|
||||
<ows:Abstract>Decay coefficient for solutes undergoing first order exponential decay (for example, radionuclides) in units of inverse time. The default is zero, corresponding to no decay.</ows:Abstract>
|
||||
<LiteralData>
|
||||
<ows:DataType ows:reference="xs:double"></ows:DataType>
|
||||
<ows:AnyValue/>
|
||||
</LiteralData>
|
||||
</Input>
|
||||
</DataInputs>
|
||||
<ProcessOutputs>
|
||||
<Output>
|
||||
<ows:Identifier>out_raster</ows:Identifier><!-- 3 -->
|
||||
<ows:Title>out raster</ows:Title>
|
||||
<ows:Abstract>The output raster the of the concentration distribution. Each cell value represents the concentration at that location.</ows:Abstract>
|
||||
<ComplexOutput>
|
||||
<Default>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Default>
|
||||
<Supported>
|
||||
<Format>
|
||||
<MimeType>application/GeoTIFF</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Supported>
|
||||
</ComplexOutput>
|
||||
</Output>
|
||||
</ProcessOutputs>
|
||||
</ProcessDescription>
|
||||
</wps:ProcessDescriptions>
|
||||
|
||||
|
||||
@ -1,61 +0,0 @@
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<wps:ProcessDescriptions xmlns:wps="http://www.opengis.net/wps/1.0.0" xmlns:ows="http://www.opengis.net/ows/1.1" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.opengis.net/wps/1.0.0
|
||||
http://schemas.opengis.net/wps/1.0.0/wpsDescribeProcess_response.xsd" xml:lang="en-US" service="WPS" version="1.0.0">
|
||||
<ProcessDescription wps:processVersion="2" statusSupported="true" storeSupported="true">
|
||||
<ows:Identifier>org.n52.wps.ags.spatialanalyst.hydrology.basin</ows:Identifier><!-- ParameterCount=2 -->
|
||||
<ows:Title>Basin_sa</ows:Title>
|
||||
<ows:Abstract>Creates a raster delineating all drainage basins. Uses ArcObjects library - Spatial Analyst</ows:Abstract>
|
||||
<DataInputs>
|
||||
<Input minOccurs="1" maxOccurs="1">
|
||||
<ows:Identifier>in_flow_direction_raster</ows:Identifier><!-- 0 -->
|
||||
<ows:Title>in flow direction raster</ows:Title>
|
||||
<ows:Abstract>The input raster that shows the direction of flow out of each cell. This is created with the Flow Direction function.</ows:Abstract>
|
||||
<ComplexData>
|
||||
<Default>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Default>
|
||||
<Supported>
|
||||
<Format>
|
||||
<MimeType>application/GeoTIFF</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Supported>
|
||||
</ComplexData>
|
||||
</Input>
|
||||
</DataInputs>
|
||||
<ProcessOutputs>
|
||||
<Output>
|
||||
<ows:Identifier>out_raster</ows:Identifier><!-- 1 -->
|
||||
<ows:Title>out raster</ows:Title>
|
||||
<ows:Abstract>The output raster that delineates the drainage basins.</ows:Abstract>
|
||||
<ComplexOutput>
|
||||
<Default>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Default>
|
||||
<Supported>
|
||||
<Format>
|
||||
<MimeType>application/GeoTIFF</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Supported>
|
||||
</ComplexOutput>
|
||||
</Output>
|
||||
</ProcessOutputs>
|
||||
</ProcessDescription>
|
||||
</wps:ProcessDescriptions>
|
||||
|
||||
|
||||
@ -1,70 +0,0 @@
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<wps:ProcessDescriptions xmlns:wps="http://www.opengis.net/wps/1.0.0" xmlns:ows="http://www.opengis.net/ows/1.1" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.opengis.net/wps/1.0.0
|
||||
http://schemas.opengis.net/wps/1.0.0/wpsDescribeProcess_response.xsd" xml:lang="en-US" service="WPS" version="1.0.0">
|
||||
<ProcessDescription wps:processVersion="2" statusSupported="true" storeSupported="true">
|
||||
<ows:Identifier>org.n52.wps.ags.spatialanalyst.hydrology.fill</ows:Identifier><!-- ParameterCount=3 -->
|
||||
<ows:Title>Fill_sa</ows:Title>
|
||||
<ows:Abstract>Fills sinks in a surface raster to remove small imperfections in the data. Uses ArcObjects library - Spatial Analyst</ows:Abstract>
|
||||
<DataInputs>
|
||||
<Input minOccurs="1" maxOccurs="1">
|
||||
<ows:Identifier>in_surface_raster</ows:Identifier><!-- 0 -->
|
||||
<ows:Title>in surface raster</ows:Title>
|
||||
<ows:Abstract>The input raster representing a continuous surface.</ows:Abstract>
|
||||
<ComplexData>
|
||||
<Default>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Default>
|
||||
<Supported>
|
||||
<Format>
|
||||
<MimeType>application/GeoTIFF</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Supported>
|
||||
</ComplexData>
|
||||
</Input>
|
||||
<Input minOccurs="0" maxOccurs="1">
|
||||
<ows:Identifier>z_limit</ows:Identifier><!-- 2 -->
|
||||
<ows:Title>z limit</ows:Title>
|
||||
<ows:Abstract>Maximum elevation difference between a sink and its pour point to be filled. If the difference in z-values between a sink and its pour point is greater than the {z_limit}, that sink will not be filled. The default is to fill all sinks, regardless of depth.</ows:Abstract>
|
||||
<LiteralData>
|
||||
<ows:DataType ows:reference="xs:double"></ows:DataType>
|
||||
<ows:AnyValue/>
|
||||
</LiteralData>
|
||||
</Input>
|
||||
</DataInputs>
|
||||
<ProcessOutputs>
|
||||
<Output>
|
||||
<ows:Identifier>out_surface_raster</ows:Identifier><!-- 1 -->
|
||||
<ows:Title>out surface raster</ows:Title>
|
||||
<ows:Abstract>The output surface raster after the sinks have been filled.</ows:Abstract>
|
||||
<ComplexOutput>
|
||||
<Default>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Default>
|
||||
<Supported>
|
||||
<Format>
|
||||
<MimeType>application/GeoTIFF</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Supported>
|
||||
</ComplexOutput>
|
||||
</Output>
|
||||
</ProcessOutputs>
|
||||
</ProcessDescription>
|
||||
</wps:ProcessDescriptions>
|
||||
|
||||
|
||||
@ -1,97 +0,0 @@
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<wps:ProcessDescriptions xmlns:wps="http://www.opengis.net/wps/1.0.0" xmlns:ows="http://www.opengis.net/ows/1.1" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.opengis.net/wps/1.0.0
|
||||
http://schemas.opengis.net/wps/1.0.0/wpsDescribeProcess_response.xsd" xml:lang="en-US" service="WPS" version="1.0.0">
|
||||
<ProcessDescription wps:processVersion="2" statusSupported="true" storeSupported="true">
|
||||
<ows:Identifier>org.n52.wps.ags.spatialanalyst.hydrology.flowaccumulation</ows:Identifier><!-- ParameterCount=4 -->
|
||||
<ows:Title>FlowAccumulation_sa</ows:Title>
|
||||
<ows:Abstract>Creates a raster of accumulated flow to each cell. Uses ArcObjects library - Spatial Analyst</ows:Abstract>
|
||||
<DataInputs>
|
||||
<Input minOccurs="1" maxOccurs="1">
|
||||
<ows:Identifier>in_flow_direction_raster</ows:Identifier><!-- 0 -->
|
||||
<ows:Title>in flow direction raster</ows:Title>
|
||||
<ows:Abstract>The input raster that records the direction of flow out of each cell. This can be created with the Flow Direction function.</ows:Abstract>
|
||||
<ComplexData>
|
||||
<Default>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Default>
|
||||
<Supported>
|
||||
<Format>
|
||||
<MimeType>application/GeoTIFF</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Supported>
|
||||
</ComplexData>
|
||||
</Input>
|
||||
<Input minOccurs="0" maxOccurs="1">
|
||||
<ows:Identifier>in_weight_raster</ows:Identifier><!-- 2 -->
|
||||
<ows:Title>in weight raster</ows:Title>
|
||||
<ows:Abstract>An optional input raster for applying a weight to each cell. If no {in_weight_raster} is specified, a default weight of one will be applied to each cell. For each cell in the output raster, the result will be the number of cells that flow into it.</ows:Abstract>
|
||||
<ComplexData>
|
||||
<Default>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Default>
|
||||
<Supported>
|
||||
<Format>
|
||||
<MimeType>application/GeoTIFF</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Supported>
|
||||
</ComplexData>
|
||||
</Input>
|
||||
<Input minOccurs="0" maxOccurs="1">
|
||||
<ows:Identifier>data_type</ows:Identifier><!-- 3 -->
|
||||
<ows:Title>output data type</ows:Title>
|
||||
<ows:Abstract>The output accumulation raster can be integer or floating point type. FLOAT — The output raster will be floating point type. This is the default. INTEGER — The output raster will be integer type.
|
||||
</ows:Abstract>
|
||||
<LiteralData>
|
||||
<ows:DataType ows:reference="xs:string"></ows:DataType>
|
||||
<ows:AllowedValues>
|
||||
<ows:Value>FLOAT</ows:Value>
|
||||
<ows:Value>INTEGER</ows:Value>
|
||||
</ows:AllowedValues>
|
||||
</LiteralData>
|
||||
</Input>
|
||||
</DataInputs>
|
||||
<ProcessOutputs>
|
||||
<Output>
|
||||
<ows:Identifier>out_accumulation_raster</ows:Identifier><!-- 1 -->
|
||||
<ows:Title>out accumulation raster</ows:Title>
|
||||
<ows:Abstract>The output raster that shows the accumulated flow to each cell.</ows:Abstract>
|
||||
<ComplexOutput>
|
||||
<Default>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Default>
|
||||
<Supported>
|
||||
<Format>
|
||||
<MimeType>application/GeoTIFF</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Supported>
|
||||
</ComplexOutput>
|
||||
</Output>
|
||||
</ProcessOutputs>
|
||||
</ProcessDescription>
|
||||
</wps:ProcessDescriptions>
|
||||
|
||||
|
||||
@ -1,94 +0,0 @@
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<wps:ProcessDescriptions xmlns:wps="http://www.opengis.net/wps/1.0.0" xmlns:ows="http://www.opengis.net/ows/1.1" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.opengis.net/wps/1.0.0
|
||||
http://schemas.opengis.net/wps/1.0.0/wpsDescribeProcess_response.xsd" xml:lang="en-US" service="WPS" version="1.0.0">
|
||||
<ProcessDescription wps:processVersion="2" statusSupported="true" storeSupported="true">
|
||||
<ows:Identifier>org.n52.wps.ags.spatialanalyst.hydrology.flowdirection</ows:Identifier><!-- ParameterCount=4 -->
|
||||
<ows:Title>FlowDirection_sa</ows:Title>
|
||||
<ows:Abstract>Creates a raster of flow direction from each cell to its steepest downslope neighbor. Uses ArcObjects library - Spatial Analyst</ows:Abstract>
|
||||
<DataInputs>
|
||||
<Input minOccurs="1" maxOccurs="1">
|
||||
<ows:Identifier>in_surface_raster</ows:Identifier><!-- 0 -->
|
||||
<ows:Title>in surface raster</ows:Title>
|
||||
<ows:Abstract>The input raster representing a continuous surface.</ows:Abstract>
|
||||
<ComplexData>
|
||||
<Default>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Default>
|
||||
<Supported>
|
||||
<Format>
|
||||
<MimeType>application/GeoTIFF</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Supported>
|
||||
</ComplexData>
|
||||
</Input>
|
||||
<Input minOccurs="0" maxOccurs="1">
|
||||
<ows:Identifier>force_flow</ows:Identifier><!-- 2 -->
|
||||
<ows:Title>force flow</ows:Title>
|
||||
<ows:Abstract>Specifies if edge cells will always flow outward or follow normal flow rules. NORMAL — If the maximum drop on the inside of an edge cell is greater than zero, the flow direction will be determined as usual; otherwise, the flow direction will be toward the edge. Cells that should flow from the edge of the surface raster inward will do so. FORCE — All cells at the edge of the surface raster will flow outward from the surface raster.
|
||||
</ows:Abstract>
|
||||
<LiteralData>
|
||||
<ows:DataType ows:reference="xs:boolean"></ows:DataType>
|
||||
<ows:AnyValue/>
|
||||
</LiteralData>
|
||||
</Input>
|
||||
</DataInputs>
|
||||
<ProcessOutputs>
|
||||
<Output>
|
||||
<ows:Identifier>out_flow_direction_raster</ows:Identifier><!-- 1 -->
|
||||
<ows:Title>out flow direction raster</ows:Title>
|
||||
<ows:Abstract>The output raster that shows the flow direction from each cell to its steepest downslope neighbor.</ows:Abstract>
|
||||
<ComplexOutput>
|
||||
<Default>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Default>
|
||||
<Supported>
|
||||
<Format>
|
||||
<MimeType>application/GeoTIFF</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Supported>
|
||||
</ComplexOutput>
|
||||
</Output>
|
||||
<Output>
|
||||
<ows:Identifier>out_drop_raster</ows:Identifier><!-- 3 -->
|
||||
<ows:Title>out drop raster</ows:Title>
|
||||
<ows:Abstract>An optional output drop raster. The drop raster shows the ratio of the maximum change in elevation from each cell along the direction of flow to the path length between centers of cells, expressed in percentages.</ows:Abstract>
|
||||
<ComplexOutput>
|
||||
<Default>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Default>
|
||||
<Supported>
|
||||
<Format>
|
||||
<MimeType>application/GeoTIFF</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Supported>
|
||||
</ComplexOutput>
|
||||
</Output>
|
||||
</ProcessOutputs>
|
||||
</ProcessDescription>
|
||||
</wps:ProcessDescriptions>
|
||||
|
||||
|
||||
@ -1,96 +0,0 @@
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<wps:ProcessDescriptions xmlns:wps="http://www.opengis.net/wps/1.0.0" xmlns:ows="http://www.opengis.net/ows/1.1" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.opengis.net/wps/1.0.0
|
||||
http://schemas.opengis.net/wps/1.0.0/wpsDescribeProcess_response.xsd" xml:lang="en-US" service="WPS" version="1.0.0">
|
||||
<ProcessDescription wps:processVersion="2" statusSupported="true" storeSupported="true">
|
||||
<ows:Identifier>org.n52.wps.ags.spatialanalyst.hydrology.flowlength</ows:Identifier><!-- ParameterCount=4 -->
|
||||
<ows:Title>FlowLength_sa</ows:Title>
|
||||
<ows:Abstract>Calculates distance or weighted distance along a flow path. Uses ArcObjects library - Spatial Analyst</ows:Abstract>
|
||||
<DataInputs>
|
||||
<Input minOccurs="1" maxOccurs="1">
|
||||
<ows:Identifier>in:flow_direction_raster</ows:Identifier><!-- 0 -->
|
||||
<ows:Title>in flow direction raster</ows:Title>
|
||||
<ows:Abstract>The input raster that records the direction of flow out of each cell. This can be created with the Flow Direction function.</ows:Abstract>
|
||||
<ComplexData>
|
||||
<Default>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Default>
|
||||
<Supported>
|
||||
<Format>
|
||||
<MimeType>application/GeoTIFF</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Supported>
|
||||
</ComplexData>
|
||||
</Input>
|
||||
<Input minOccurs="0" maxOccurs="1">
|
||||
<ows:Identifier>in_weight_raster</ows:Identifier><!-- 3 -->
|
||||
<ows:Title>in weight raster</ows:Title>
|
||||
<ows:Abstract>The weight to be assigned to each cell. If no {in_weight_raster} is specified, a default weight of one will be applied to each cell. For each cell in the output raster, the result will be the number of cells that flow into it.</ows:Abstract>
|
||||
<ComplexData>
|
||||
<Default>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Default>
|
||||
<Supported>
|
||||
<Format>
|
||||
<MimeType>application/GeoTIFF</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Supported>
|
||||
</ComplexData>
|
||||
</Input>
|
||||
<Input minOccurs="0" maxOccurs="1">
|
||||
<ows:Identifier>direction_measurement</ows:Identifier><!-- 2 -->
|
||||
<ows:Title>direction measurement</ows:Title>
|
||||
<ows:Abstract>The direction of measurement along the flow path. DOWNSTREAM — Calculates the downslope distance along the flow path, from each cell to a sink or outlet on the edge of the raster. UPSTREAM — Calculates the longest upslope distance along the flow path, from each cell to the top of the drainage divide.</ows:Abstract>
|
||||
<LiteralData>
|
||||
<ows:DataType ows:reference="xs:string"></ows:DataType>
|
||||
<ows:AllowedValues>
|
||||
<ows:Value>DOWNSTREAM</ows:Value>
|
||||
<ows:Value>UPSTREAM</ows:Value>
|
||||
</ows:AllowedValues>
|
||||
</LiteralData>
|
||||
</Input>
|
||||
</DataInputs>
|
||||
<ProcessOutputs>
|
||||
<Output>
|
||||
<ows:Identifier>out_raster</ows:Identifier><!-- 1 -->
|
||||
<ows:Title>out raster</ows:Title>
|
||||
<ows:Abstract>The output raster that shows for each cell the upstream or downstream distance along a flow path.</ows:Abstract>
|
||||
<ComplexOutput>
|
||||
<Default>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Default>
|
||||
<Supported>
|
||||
<Format>
|
||||
<MimeType>application/GeoTIFF</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Supported>
|
||||
</ComplexOutput>
|
||||
</Output>
|
||||
</ProcessOutputs>
|
||||
</ProcessDescription>
|
||||
</wps:ProcessDescriptions>
|
||||
|
||||
|
||||
@ -1,61 +0,0 @@
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<wps:ProcessDescriptions xmlns:wps="http://www.opengis.net/wps/1.0.0" xmlns:ows="http://www.opengis.net/ows/1.1" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.opengis.net/wps/1.0.0
|
||||
http://schemas.opengis.net/wps/1.0.0/wpsDescribeProcess_response.xsd" xml:lang="en-US" service="WPS" version="1.0.0">
|
||||
<ProcessDescription wps:processVersion="2" statusSupported="true" storeSupported="true">
|
||||
<ows:Identifier>org.n52.wps.ags.spatialanalyst.hydrology.sink</ows:Identifier><!-- ParameterCount=2 -->
|
||||
<ows:Title>Sink_sa</ows:Title>
|
||||
<ows:Abstract>Creates a raster identifying all sinks or areas of internal drainage. Uses ArcObjects library - Spatial Analyst</ows:Abstract>
|
||||
<DataInputs>
|
||||
<Input minOccurs="1" maxOccurs="1">
|
||||
<ows:Identifier>in_flow_direction_raster</ows:Identifier><!-- 0 -->
|
||||
<ows:Title>in flow direction raster</ows:Title>
|
||||
<ows:Abstract>The input raster that records the direction of flow out of each cell. This is created with the Flow Direction function.</ows:Abstract>
|
||||
<ComplexData>
|
||||
<Default>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Default>
|
||||
<Supported>
|
||||
<Format>
|
||||
<MimeType>application/GeoTIFF</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Supported>
|
||||
</ComplexData>
|
||||
</Input>
|
||||
</DataInputs>
|
||||
<ProcessOutputs>
|
||||
<Output>
|
||||
<ows:Identifier>out_raster</ows:Identifier><!-- 1 -->
|
||||
<ows:Title>out raster</ows:Title>
|
||||
<ows:Abstract>The output raster that shows all the sinks (areas of internal drainage) on the input surface.</ows:Abstract>
|
||||
<ComplexOutput>
|
||||
<Default>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Default>
|
||||
<Supported>
|
||||
<Format>
|
||||
<MimeType>application/GeoTIFF</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Supported>
|
||||
</ComplexOutput>
|
||||
</Output>
|
||||
</ProcessOutputs>
|
||||
</ProcessDescription>
|
||||
</wps:ProcessDescriptions>
|
||||
|
||||
|
||||
@ -1,102 +0,0 @@
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<wps:ProcessDescriptions xmlns:wps="http://www.opengis.net/wps/1.0.0" xmlns:ows="http://www.opengis.net/ows/1.1" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.opengis.net/wps/1.0.0
|
||||
http://schemas.opengis.net/wps/1.0.0/wpsDescribeProcess_response.xsd" xml:lang="en-US" service="WPS" version="1.0.0">
|
||||
<ProcessDescription wps:processVersion="2" statusSupported="true" storeSupported="true">
|
||||
<ows:Identifier>org.n52.wps.ags.spatialanalyst.hydrology.snappourpoint</ows:Identifier><!-- ParameterCount=5 -->
|
||||
<ows:Title>SnapPourPoint_sa</ows:Title>
|
||||
<ows:Abstract>Snaps pour points to the cell of highest flow accumulation within a specified distance. Uses ArcObjects library - Spatial Analyst</ows:Abstract>
|
||||
<DataInputs>
|
||||
<Input minOccurs="1" maxOccurs="1">
|
||||
<ows:Identifier>in_pour_point_data</ows:Identifier><!-- 0 -->
|
||||
<ows:Title>in pour point data</ows:Title>
|
||||
<ows:Abstract>The input pour point locations that are to be snapped. For rasters, all cells that are not NoData (i.e. have a value) will be considered pour points and will be snapped. For point datasets, specifies the locations of cells that will be snapped.</ows:Abstract>
|
||||
<ComplexData>
|
||||
<Default>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Default>
|
||||
<Supported>
|
||||
<Format>
|
||||
<MimeType>application/GeoTIFF</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Supported>
|
||||
</ComplexData>
|
||||
</Input>
|
||||
<Input minOccurs="1" maxOccurs="1">
|
||||
<ows:Identifier>in_accumulation_raster</ows:Identifier><!-- 1 -->
|
||||
<ows:Title>in accumulation raster</ows:Title>
|
||||
<ows:Abstract>The input flow accumulation raster. This can be created with the Flow Accumulation function.</ows:Abstract>
|
||||
<ComplexData>
|
||||
<Default>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Default>
|
||||
<Supported>
|
||||
<Format>
|
||||
<MimeType>application/GeoTIFF</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Supported>
|
||||
</ComplexData>
|
||||
</Input>
|
||||
<Input minOccurs="0" maxOccurs="1">
|
||||
<ows:Identifier>pour_point_field</ows:Identifier><!-- 4 -->
|
||||
<ows:Title>pour point field</ows:Title>
|
||||
<ows:Abstract>Field used to assign values to the pour point locations. If in_pour_point_data is a raster, use Value. If in_pour_point_data is a feature, use a numeric field. If the field contains floating-point values, they will be truncated into integers.</ows:Abstract>
|
||||
<LiteralData>
|
||||
<ows:DataType ows:reference="xs:string"></ows:DataType>
|
||||
<ows:AnyValue/>
|
||||
</LiteralData>
|
||||
</Input>
|
||||
<Input minOccurs="1" maxOccurs="1">
|
||||
<ows:Identifier>snap_distance</ows:Identifier><!-- 3 -->
|
||||
<ows:Title>snap distance</ows:Title>
|
||||
<ows:Abstract>Maximum distance, in map units, to search for a cell of higher accumulated flow.</ows:Abstract>
|
||||
<LiteralData>
|
||||
<ows:DataType ows:reference="xs:double"></ows:DataType>
|
||||
<ows:AnyValue/>
|
||||
</LiteralData>
|
||||
</Input>
|
||||
</DataInputs>
|
||||
<ProcessOutputs>
|
||||
<Output>
|
||||
<ows:Identifier>out_raster</ows:Identifier><!-- 2 -->
|
||||
<ows:Title>out raster</ows:Title>
|
||||
<ows:Abstract>The raster to be created.</ows:Abstract>
|
||||
<ComplexOutput>
|
||||
<Default>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Default>
|
||||
<Supported>
|
||||
<Format>
|
||||
<MimeType>application/GeoTIFF</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Supported>
|
||||
</ComplexOutput>
|
||||
</Output>
|
||||
</ProcessOutputs>
|
||||
</ProcessDescription>
|
||||
</wps:ProcessDescriptions>
|
||||
|
||||
|
||||
@ -1,84 +0,0 @@
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<wps:ProcessDescriptions xmlns:wps="http://www.opengis.net/wps/1.0.0" xmlns:ows="http://www.opengis.net/ows/1.1" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.opengis.net/wps/1.0.0
|
||||
http://schemas.opengis.net/wps/1.0.0/wpsDescribeProcess_response.xsd" xml:lang="en-US" service="WPS" version="1.0.0">
|
||||
<ProcessDescription wps:processVersion="2" statusSupported="true" storeSupported="true">
|
||||
<ows:Identifier>org.n52.wps.ags.spatialanalyst.hydrology.streamlink</ows:Identifier><!-- ParameterCount=3 -->
|
||||
<ows:Title>StreamLink_sa</ows:Title>
|
||||
<ows:Abstract>Assigns unique values to sections of a raster linear network between intersections. Uses ArcObjects library - Spatial Analyst</ows:Abstract>
|
||||
<DataInputs>
|
||||
<Input minOccurs="1" maxOccurs="1">
|
||||
<ows:Identifier>in_stream_raster</ows:Identifier><!-- 0 -->
|
||||
<ows:Title>in stream raster</ows:Title>
|
||||
<ows:Abstract>An input raster that represents a linear stream network. </ows:Abstract>
|
||||
<ComplexData>
|
||||
<Default>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Default>
|
||||
<Supported>
|
||||
<Format>
|
||||
<MimeType>application/GeoTIFF</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Supported>
|
||||
</ComplexData>
|
||||
</Input>
|
||||
<Input minOccurs="1" maxOccurs="1">
|
||||
<ows:Identifier>in_flow_direction_raster</ows:Identifier><!-- 1 -->
|
||||
<ows:Title>in flow direction raster</ows:Title>
|
||||
<ows:Abstract>The input raster that records the direction of flow out of each cell. This is created with the Flow Direction function.</ows:Abstract>
|
||||
<ComplexData>
|
||||
<Default>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Default>
|
||||
<Supported>
|
||||
<Format>
|
||||
<MimeType>application/GeoTIFF</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Supported>
|
||||
</ComplexData>
|
||||
</Input>
|
||||
</DataInputs>
|
||||
<ProcessOutputs>
|
||||
<Output>
|
||||
<ows:Identifier>out_raster</ows:Identifier><!-- 2 -->
|
||||
<ows:Title>out raster</ows:Title>
|
||||
<ows:Abstract>The output stream link raster.</ows:Abstract>
|
||||
<ComplexOutput>
|
||||
<Default>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Default>
|
||||
<Supported>
|
||||
<Format>
|
||||
<MimeType>application/GeoTIFF</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Supported>
|
||||
</ComplexOutput>
|
||||
</Output>
|
||||
</ProcessOutputs>
|
||||
</ProcessDescription>
|
||||
</wps:ProcessDescriptions>
|
||||
|
||||
|
||||
@ -1,97 +0,0 @@
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<wps:ProcessDescriptions xmlns:wps="http://www.opengis.net/wps/1.0.0" xmlns:ows="http://www.opengis.net/ows/1.1" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.opengis.net/wps/1.0.0
|
||||
http://schemas.opengis.net/wps/1.0.0/wpsDescribeProcess_response.xsd" xml:lang="en-US" service="WPS" version="1.0.0">
|
||||
<ProcessDescription wps:processVersion="2" statusSupported="true" storeSupported="true">
|
||||
<ows:Identifier>org.n52.wps.ags.spatialanalyst.hydrology.streamorder</ows:Identifier><!-- ParameterCount=4 -->
|
||||
<ows:Title>StreamOrder_sa</ows:Title>
|
||||
<ows:Abstract>Assigns a numeric order to segments of a raster representing branches of a linear network. Uses ArcObjects library - Spatial Analyst</ows:Abstract>
|
||||
<DataInputs>
|
||||
<Input minOccurs="1" maxOccurs="1">
|
||||
<ows:Identifier>in_stream_raster</ows:Identifier><!-- 0 -->
|
||||
<ows:Title>in stream raster</ows:Title>
|
||||
<ows:Abstract>An input raster that represents a linear stream network.</ows:Abstract>
|
||||
<ComplexData>
|
||||
<Default>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Default>
|
||||
<Supported>
|
||||
<Format>
|
||||
<MimeType>application/GeoTIFF</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Supported>
|
||||
</ComplexData>
|
||||
</Input>
|
||||
<Input minOccurs="1" maxOccurs="1">
|
||||
<ows:Identifier>in_flow_direction_raster</ows:Identifier><!-- 1 -->
|
||||
<ows:Title>in flow direction raster</ows:Title>
|
||||
<ows:Abstract>The input raster that records the direction of flow out of each cell. This can be created with the Flow Direction function.</ows:Abstract>
|
||||
<ComplexData>
|
||||
<Default>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Default>
|
||||
<Supported>
|
||||
<Format>
|
||||
<MimeType>application/GeoTIFF</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Supported>
|
||||
</ComplexData>
|
||||
</Input>
|
||||
<Input minOccurs="0" maxOccurs="1">
|
||||
<ows:Identifier>order_method</ows:Identifier><!-- 3 -->
|
||||
<ows:Title>order method</ows:Title>
|
||||
<ows:Abstract>The method used for assigning stream order. STRAHLER — The method of stream ordering proposed by Strahler in 1952. Stream order only increases when streams of the same order intersect. Therefore, the intersection of a first-order and second-order link will remain a second-order link, rather than create a third-order link. This is the default. SHREVE — The method of stream ordering by magnitude, proposed by Shreve in 1967. All links with no tributaries are assigned a magnitude (order) of one. Magnitudes are additive downslope. When two links intersect, their magnitudes are added and assigned to the downslope link.
|
||||
</ows:Abstract>
|
||||
<LiteralData>
|
||||
<ows:DataType ows:reference="xs:string"></ows:DataType>
|
||||
<ows:AllowedValues>
|
||||
<ows:Value>STRAHLER</ows:Value>
|
||||
<ows:Value>SHREVE</ows:Value>
|
||||
</ows:AllowedValues>
|
||||
</LiteralData>
|
||||
</Input>
|
||||
</DataInputs>
|
||||
<ProcessOutputs>
|
||||
<Output>
|
||||
<ows:Identifier>out_raster</ows:Identifier><!-- 2 -->
|
||||
<ows:Title>out raster</ows:Title>
|
||||
<ows:Abstract>The output stream order raster.</ows:Abstract>
|
||||
<ComplexOutput>
|
||||
<Default>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Default>
|
||||
<Supported>
|
||||
<Format>
|
||||
<MimeType>application/GeoTIFF</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Supported>
|
||||
</ComplexOutput>
|
||||
</Output>
|
||||
</ProcessOutputs>
|
||||
</ProcessDescription>
|
||||
</wps:ProcessDescriptions>
|
||||
|
||||
|
||||
@ -1,89 +0,0 @@
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<wps:ProcessDescriptions xmlns:wps="http://www.opengis.net/wps/1.0.0" xmlns:ows="http://www.opengis.net/ows/1.1" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.opengis.net/wps/1.0.0
|
||||
http://schemas.opengis.net/wps/1.0.0/wpsDescribeProcess_response.xsd" xml:lang="en-US" service="WPS" version="1.0.0">
|
||||
<ProcessDescription wps:processVersion="2" statusSupported="true" storeSupported="true">
|
||||
<ows:Identifier>org.n52.wps.ags.spatialanalyst.hydrology.streamtofeature</ows:Identifier><!-- ParameterCount=4 -->
|
||||
<ows:Title>StreamToFeature_sa</ows:Title>
|
||||
<ows:Abstract>Converts a raster representing a linear network to features representing the linear network. Uses ArcObjects library - Spatial Analyst</ows:Abstract>
|
||||
<DataInputs>
|
||||
<Input minOccurs="1" maxOccurs="1">
|
||||
<ows:Identifier>in_stream_raster</ows:Identifier><!-- 0 -->
|
||||
<ows:Title>in stream raster</ows:Title>
|
||||
<ows:Abstract>An input raster that represents a linear stream network.</ows:Abstract>
|
||||
<ComplexData>
|
||||
<Default>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Default>
|
||||
<Supported>
|
||||
<Format>
|
||||
<MimeType>application/GeoTIFF</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Supported>
|
||||
</ComplexData>
|
||||
</Input>
|
||||
<Input minOccurs="1" maxOccurs="1">
|
||||
<ows:Identifier>in_flow_direction_raster</ows:Identifier><!-- 1 -->
|
||||
<ows:Title>in flow direction raster</ows:Title>
|
||||
<ows:Abstract>The input raster that records the direction of flow out of each cell. This can be created with the Flow Direction function.</ows:Abstract>
|
||||
<ComplexData>
|
||||
<Default>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Default>
|
||||
<Supported>
|
||||
<Format>
|
||||
<MimeType>application/GeoTIFF</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Supported>
|
||||
</ComplexData>
|
||||
</Input>
|
||||
<Input minOccurs="0" maxOccurs="1">
|
||||
<ows:Identifier>simplify</ows:Identifier><!-- 3 -->
|
||||
<ows:Title>simplify</ows:Title>
|
||||
<ows:Abstract>Specifies whether weeding is used. SIMPLIFY — The feature is weeded to reduce the number of vertices. The Douglas-Puecker algorithm for line generalization is used, with a tolerance of sqrt(0.5) * cell size. NO_SIMPLIFY — No weeding is applied. By default, weeding is applied.</ows:Abstract>
|
||||
<LiteralData>
|
||||
<ows:DataType ows:reference="xs:boolean"></ows:DataType>
|
||||
<ows:AnyValue/>
|
||||
</LiteralData>
|
||||
</Input>
|
||||
</DataInputs>
|
||||
<ProcessOutputs>
|
||||
<Output>
|
||||
<ows:Identifier>output_polyline_feature</ows:Identifier><!-- 2 -->
|
||||
<ows:Title>output polyline features</ows:Title>
|
||||
<ows:Abstract>Output feature class that will hold the converted streams.</ows:Abstract>
|
||||
<ComplexOutput>
|
||||
<Default>
|
||||
<Format>
|
||||
<MimeType>application/x-zipped-shp</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Default>
|
||||
<Supported>
|
||||
<Format>
|
||||
<MimeType>application/x-zipped-shp</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Supported>
|
||||
</ComplexOutput>
|
||||
</Output>
|
||||
</ProcessOutputs>
|
||||
</ProcessDescription>
|
||||
</wps:ProcessDescriptions>
|
||||
|
||||
|
||||
@ -1,93 +0,0 @@
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<wps:ProcessDescriptions xmlns:wps="http://www.opengis.net/wps/1.0.0" xmlns:ows="http://www.opengis.net/ows/1.1" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.opengis.net/wps/1.0.0
|
||||
http://schemas.opengis.net/wps/1.0.0/wpsDescribeProcess_response.xsd" xml:lang="en-US" service="WPS" version="1.0.0">
|
||||
<ProcessDescription wps:processVersion="2" statusSupported="true" storeSupported="true">
|
||||
<ows:Identifier>org.n52.wps.ags.spatialanalyst.hydrology.watershed</ows:Identifier><!-- ParameterCount=4 -->
|
||||
<ows:Title>Watershed_sa</ows:Title>
|
||||
<ows:Abstract>Determines the contributing area above a set of cells in a raster. Uses ArcObjects library - Spatial Analyst</ows:Abstract>
|
||||
<DataInputs>
|
||||
<Input minOccurs="1" maxOccurs="1">
|
||||
<ows:Identifier>in_flow_direction_raster</ows:Identifier><!-- 0 -->
|
||||
<ows:Title>in flow direction raster</ows:Title>
|
||||
<ows:Abstract>The input raster that records the direction of flow out of each cell. This can be created with the Flow Direction function.</ows:Abstract>
|
||||
<ComplexData>
|
||||
<Default>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Default>
|
||||
<Supported>
|
||||
<Format>
|
||||
<MimeType>application/GeoTIFF</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Supported>
|
||||
</ComplexData>
|
||||
</Input>
|
||||
<Input minOccurs="1" maxOccurs="1">
|
||||
<ows:Identifier>in_pour_point_data</ows:Identifier><!-- 1 -->
|
||||
<ows:Title>in pour point data</ows:Title>
|
||||
<ows:Abstract>The input pour point locations. For a raster, this represents cells above which the contributing area, or catchment, will be determined. All cells that are not NoData will be used as source cells. For a feature dataset, this represents locations above which the contributing area, or catchment, will be determined.</ows:Abstract>
|
||||
<ComplexData>
|
||||
<Default>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Default>
|
||||
<Supported>
|
||||
<Format>
|
||||
<MimeType>application/GeoTIFF</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Supported>
|
||||
</ComplexData>
|
||||
</Input>
|
||||
<Input minOccurs="0" maxOccurs="1">
|
||||
<ows:Identifier>pour_point_field</ows:Identifier><!-- 3 -->
|
||||
<ows:Title>pour point field</ows:Title>
|
||||
<ows:Abstract>Field used to assign values to the pour point locations. If in_pour_point_data is raster, use Value. If in_pour_point_data is feature, use the first numeric field.</ows:Abstract>
|
||||
<LiteralData>
|
||||
<ows:DataType ows:reference="xs:string"></ows:DataType>
|
||||
<ows:AnyValue/>
|
||||
</LiteralData>
|
||||
</Input>
|
||||
</DataInputs>
|
||||
<ProcessOutputs>
|
||||
<Output>
|
||||
<ows:Identifier>out_raster</ows:Identifier><!-- 2 -->
|
||||
<ows:Title>out raster</ows:Title>
|
||||
<ows:Abstract>The raster to be created.</ows:Abstract>
|
||||
<ComplexOutput>
|
||||
<Default>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Default>
|
||||
<Supported>
|
||||
<Format>
|
||||
<MimeType>application/GeoTIFF</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Supported>
|
||||
</ComplexOutput>
|
||||
</Output>
|
||||
</ProcessOutputs>
|
||||
</ProcessDescription>
|
||||
</wps:ProcessDescriptions>
|
||||
|
||||
|
||||
@ -1,75 +0,0 @@
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<wps:ProcessDescriptions xmlns:wps="http://www.opengis.net/wps/1.0.0" xmlns:ows="http://www.opengis.net/ows/1.1" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.opengis.net/wps/1.0.0
|
||||
http://schemas.opengis.net/wps/1.0.0/wpsDescribeProcess_response.xsd" xml:lang="en-US" service="WPS" version="1.0.0">
|
||||
<ProcessDescription wps:processVersion="2" statusSupported="true" storeSupported="true">
|
||||
<ows:Identifier>org.n52.wps.ags.spatialanalyst.interpolation.naturalneighbor</ows:Identifier><!-- ParameterCount=4 -->
|
||||
<ows:Title>NaturalNeighbor_sa</ows:Title>
|
||||
<ows:Abstract>Interpolates a surface from points using a natural neighbor technique. Uses ArcObjects library - Spatial Analyst</ows:Abstract>
|
||||
<DataInputs>
|
||||
<Input minOccurs="1" maxOccurs="1">
|
||||
<ows:Identifier>in_point_features</ows:Identifier><!-- 0 -->
|
||||
<ows:Title>in point features</ows:Title>
|
||||
<ows:Abstract>The input point features containing the z-values to be interpolated into a surface raster.</ows:Abstract>
|
||||
<ComplexData>
|
||||
<Default>
|
||||
<Format>
|
||||
<MimeType>application/x-zipped-shp</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Default>
|
||||
<Supported>
|
||||
<Format>
|
||||
<MimeType>application/x-zipped-shp</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Supported>
|
||||
</ComplexData>
|
||||
</Input>
|
||||
<Input minOccurs="1" maxOccurs="1">
|
||||
<ows:Identifier>z_field</ows:Identifier><!-- 1 -->
|
||||
<ows:Title>z field</ows:Title>
|
||||
<ows:Abstract>Field that holds a height or magnitude value for each point. This can be a numeric field or the Shape field if the Input point features contain z-values.</ows:Abstract>
|
||||
<LiteralData>
|
||||
<ows:DataType ows:reference="xs:string"></ows:DataType>
|
||||
<ows:AnyValue/>
|
||||
</LiteralData>
|
||||
</Input>
|
||||
<Input minOccurs="0" maxOccurs="1">
|
||||
<ows:Identifier>cell_size</ows:Identifier><!-- 3 -->
|
||||
<ows:Title>cell size</ows:Title>
|
||||
<ows:Abstract>The cell size at which the output raster will be created. This will be the value in the Environment if it is explicitly set. Otherwise, it is the shorter of the width or the height of the extent of in_point_features in the input spatial reference, divided by 250.</ows:Abstract>
|
||||
<LiteralData>
|
||||
<ows:DataType ows:reference="xs:double"></ows:DataType>
|
||||
<ows:AnyValue/>
|
||||
</LiteralData>
|
||||
</Input>
|
||||
</DataInputs>
|
||||
<ProcessOutputs>
|
||||
<Output>
|
||||
<ows:Identifier>out_raster</ows:Identifier><!-- 2 -->
|
||||
<ows:Title>out raster</ows:Title>
|
||||
<ows:Abstract>The output raster surface to be created.</ows:Abstract>
|
||||
<ComplexOutput>
|
||||
<Default>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Default>
|
||||
<Supported>
|
||||
<Format>
|
||||
<MimeType>application/GeoTIFF</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Supported>
|
||||
</ComplexOutput>
|
||||
</Output>
|
||||
</ProcessOutputs>
|
||||
</ProcessDescription>
|
||||
</wps:ProcessDescriptions>
|
||||
|
||||
|
||||
@ -1,106 +0,0 @@
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<wps:ProcessDescriptions xmlns:wps="http://www.opengis.net/wps/1.0.0" xmlns:ows="http://www.opengis.net/ows/1.1" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.opengis.net/wps/1.0.0
|
||||
http://schemas.opengis.net/wps/1.0.0/wpsDescribeProcess_response.xsd" xml:lang="en-US" service="WPS" version="1.0.0">
|
||||
<ProcessDescription wps:processVersion="2" statusSupported="true" storeSupported="true">
|
||||
<ows:Identifier>org.n52.wps.ags.spatialanalyst.interpolation.spline</ows:Identifier><!-- ParameterCount=7 -->
|
||||
<ows:Title>Spline_sa</ows:Title>
|
||||
<ows:Abstract>Interpolates a surface from points using a minimum curvature spline technique. Uses ArcObjects library - Spatial Analyst</ows:Abstract>
|
||||
<DataInputs>
|
||||
<Input minOccurs="1" maxOccurs="1">
|
||||
<ows:Identifier>in_point_features</ows:Identifier><!-- 0 -->
|
||||
<ows:Title>in point features</ows:Title>
|
||||
<ows:Abstract>The input point features containing the z-values to be interpolated into a surface raster.</ows:Abstract>
|
||||
<ComplexData>
|
||||
<Default>
|
||||
<Format>
|
||||
<MimeType>application/x-zipped-shp</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Default>
|
||||
<Supported>
|
||||
<Format>
|
||||
<MimeType>application/x-zipped-shp</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Supported>
|
||||
</ComplexData>
|
||||
</Input>
|
||||
<Input minOccurs="1" maxOccurs="1">
|
||||
<ows:Identifier>z_field</ows:Identifier><!-- 1 -->
|
||||
<ows:Title>z field</ows:Title>
|
||||
<ows:Abstract>Field that holds a height or magnitude value for each point. This can be a numeric field or the shape field, if the in_point_features contain z-values.</ows:Abstract>
|
||||
<LiteralData>
|
||||
<ows:DataType ows:reference="xs:string"></ows:DataType>
|
||||
<ows:AnyValue/>
|
||||
</LiteralData>
|
||||
</Input>
|
||||
<Input minOccurs="0" maxOccurs="1">
|
||||
<ows:Identifier>cell_size</ows:Identifier><!-- 3 -->
|
||||
<ows:Title>cell size</ows:Title>
|
||||
<ows:Abstract>The cell size at which the output raster will be created. This will be the value in the Environment if it is explicitly set. Otherwise, it is the shorter of the width or the height of the extent of in_point_features, in the input spatial reference, divided by 250.</ows:Abstract>
|
||||
<LiteralData>
|
||||
<ows:DataType ows:reference="xs:double"></ows:DataType>
|
||||
<ows:AnyValue/>
|
||||
</LiteralData>
|
||||
</Input>
|
||||
<Input minOccurs="0" maxOccurs="1">
|
||||
<ows:Identifier>spline_type</ows:Identifier><!-- 4 -->
|
||||
<ows:Title>spline type</ows:Title>
|
||||
<ows:Abstract>The type of spline to be used. REGULARIZED — Yields a smooth surface and smooth first derivatives. TENSION — Tunes the stiffness of the interpolant according to the character of the modeled phenomenon.
|
||||
</ows:Abstract>
|
||||
<LiteralData>
|
||||
<ows:DataType ows:reference="xs:string"></ows:DataType>
|
||||
<ows:AllowedValues>
|
||||
<ows:Value>REGULARIZED</ows:Value>
|
||||
<ows:Value>TENSION</ows:Value>
|
||||
</ows:AllowedValues>
|
||||
</LiteralData>
|
||||
</Input>
|
||||
<Input minOccurs="0" maxOccurs="1">
|
||||
<ows:Identifier>weight</ows:Identifier><!-- 5 -->
|
||||
<ows:Title>weight</ows:Title>
|
||||
<ows:Abstract>Parameter influencing the character of the surface interpolation. When the REGULARIZED option is used, it defines the weight of the third derivatives of the surface in the curvature minimization expression. If the TENSION option is used, it defines the weight of tension. The default weight is 0.1.</ows:Abstract>
|
||||
<LiteralData>
|
||||
<ows:DataType ows:reference="xs:double"></ows:DataType>
|
||||
<ows:AnyValue/>
|
||||
</LiteralData>
|
||||
</Input>
|
||||
<Input minOccurs="0" maxOccurs="1">
|
||||
<ows:Identifier>number_points</ows:Identifier><!-- 6 -->
|
||||
<ows:Title>number points</ows:Title>
|
||||
<ows:Abstract>The number of points per region used for local approximation. The default is 12.</ows:Abstract>
|
||||
<LiteralData>
|
||||
<ows:DataType ows:reference="xs:double"></ows:DataType>
|
||||
<ows:AnyValue/>
|
||||
</LiteralData>
|
||||
</Input>
|
||||
</DataInputs>
|
||||
<ProcessOutputs>
|
||||
<Output>
|
||||
<ows:Identifier>out_raster</ows:Identifier><!-- 2 -->
|
||||
<ows:Title>out raster</ows:Title>
|
||||
<ows:Abstract>The output raster surface to be created.</ows:Abstract>
|
||||
<ComplexOutput>
|
||||
<Default>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Default>
|
||||
<Supported>
|
||||
<Format>
|
||||
<MimeType>application/GeoTIFF</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
<Format>
|
||||
<MimeType>application/img</MimeType>
|
||||
<Schema></Schema>
|
||||
</Format>
|
||||
</Supported>
|
||||
</ComplexOutput>
|
||||
</Output>
|
||||
</ProcessOutputs>
|
||||
</ProcessDescription>
|
||||
</wps:ProcessDescriptions>
|
||||
|
||||
|
||||
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in New Issue