<?xml version="1.0" encoding="UTF-8"?>
<SextanteProcesses configVersion="0.1.0"
  xmlns="http://www.deegree.org/processes/sextante" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://www.deegree.org/processes/sextante sextante.xsd">

  <Process id="boundingbox">
    <Abstract>This algorithm generates a new vector layer with a single polygon representing the bounding box of an input vector layer.</Abstract>
    <InputParameters>
      <Parameter id="LAYER">
        <Abstract>The input layer</Abstract>
      </Parameter>
    </InputParameters>
    <OutputParameters>
      <Parameter id="RESULT">
        <Abstract>The output layer with just a single polygon which defines the bounding box of the input layer</Abstract>
      </Parameter>
    </OutputParameters>
  </Process>
  <Process id="centroids">
    <Abstract>Creates a new points layer with the centroids of the polygons in a given layer.</Abstract>
    <InputParameters>
      <Parameter id="LAYER">
        <Abstract>The input polygons layer</Abstract>
      </Parameter>
    </InputParameters>
    <OutputParameters>
      <Parameter id="RESULT">
        <Abstract>The centroids. The attributes table associated with this layer is the same as the one of the input layer</Abstract>
      </Parameter>
    </OutputParameters>
  </Process>
  <Process id="changelinedirection">
    <Abstract>This algorithm inverts the ordering of vertices in a line, thus reversing its orientation</Abstract>
    <InputParameters>
      <Parameter id="LINES">
        <Abstract>The input layer</Abstract>
      </Parameter>
    </InputParameters>
    <OutputParameters>
      <Parameter id="RESULT">
        <Abstract>new layer with inverted lines</Abstract>
      </Parameter>
    </OutputParameters>
  </Process>
  <Process id="cleanpointslayer">
    <Abstract>This algorithm eliminates duplicated points. If several points with the same coordinates appear in a layer, the algorithm will leave just the first one of them, removing the remaining ones.</Abstract>
    <InputParameters>
      <Parameter id="LAYER">
        <Abstract>The input points layer</Abstract>
      </Parameter>
    </InputParameters>
    <OutputParameters>
      <Parameter id="RESULT">
        <Abstract>The cleaned layer</Abstract>
      </Parameter>
    </OutputParameters>
  </Process>
  <Process id="cleanvectorlayer">
    <Abstract>This algorithms checks the integrity of the attributes tables of a vector layer and removes invalid features (features with missing attributes or invalid values).The number of invalid features is shown in a message in the SEXTANTE log window.</Abstract>
    <InputParameters>
      <Parameter id="LAYER">
        <Abstract>The vector layer to clean</Abstract>
      </Parameter>
    </InputParameters>
    <OutputParameters>
      <Parameter id="RESULT">
        <Abstract>The cleaned vector layer, after removing invalid features.</Abstract>
      </Parameter>
    </OutputParameters>
  </Process>
  <Process id="clip">
    <Abstract>This algorithm clips a vector layer using the polygons from an additional polygons layer</Abstract>
    <InputParameters>
      <Parameter id="LAYER">
        <Abstract>The input layer to be clipped.</Abstract>
      </Parameter>
      <Parameter id="CLIPLAYER">
        <Abstract>The polygons layer to use as clipping layer</Abstract>
      </Parameter>
    </InputParameters>
    <OutputParameters>
      <Parameter id="RESULT">
        <Abstract>The output layer.</Abstract>
      </Parameter>
    </OutputParameters>
  </Process>
  <Process id="countpoints">
    <Abstract>This algorithm counts the points in each polygon of a given vector layer</Abstract>
    <InputParameters>
      <Parameter id="POINTS">
        <Abstract>The input points layer</Abstract>
      </Parameter>
      <Parameter id="POLYGONS">
        <Abstract>The input polygons layer.</Abstract>
      </Parameter>
    </InputParameters>
    <OutputParameters>
      <Parameter id="RESULT">
        <Abstract>inner points</Abstract>
      </Parameter>
    </OutputParameters>
  </Process>
  <Process id="delaunay">
    <Abstract>This algorithm creates a Delaunay triangulation from a set of points</Abstract>
    <InputParameters>
      <Parameter id="POINTS">
        <Abstract>Points layers</Abstract>
      </Parameter>
    </InputParameters>
    <OutputParameters>
      <Parameter id="TRIANGLES">
        <Abstract>Resultado</Abstract>
      </Parameter>
    </OutputParameters>
  </Process>
  <Process id="difference">
    <Abstract>El geoproceso diferencia genera una nueva capa con las zonas que no entran dentro de la zona definida por la capa de recorte. Las geometrias deben ser de poligonos. La diferencia es un operador contrario al recorte. Mientras que el recorte es util para restringir la informacion de una capa vectorial a un area dada, la diferencia es util cuando deseamos excluir dicho area de la capa.En la siguiente figura se ha empleado como [capa a recortar] el poligono azul y como [capa de recorte], o capa de solape, el poligono verde (A). El resultado (B) es una nueva capa de poligonos con la zona de la capa (capa a recortar) que no esta presente en la otra capa (capa de recorte). </Abstract>
    <InputParameters>
      <Parameter id="LAYER">
        <Abstract>la capa que se desea recortar.</Abstract>
      </Parameter>
      <Parameter id="CLIPLAYER">
        <Abstract>la capa de que actua como de recorte o solape.</Abstract>
      </Parameter>
    </InputParameters>
    <OutputParameters>
      <Parameter id="RESULT">
        <Abstract>Diferencia</Abstract>
      </Parameter>
    </OutputParameters>
  </Process>
  <Process id="extractendpointsoflines">
    <Abstract>Este algoritmo toma una capa de lineas y crea a partir de ella una capa de puntos, aadiendo unicamente los puntos inicial y final de cada linea.</Abstract>
    <InputParameters>
      <Parameter id="LAYER">
        <Abstract>La capa de lineas de entrada.</Abstract>
      </Parameter>
    </InputParameters>
    <OutputParameters>
      <Parameter id="RESULT">
        <Abstract>La capa de puntos, con los puntos extremos de las lineas de entrada. La tabla de atributos contiene dos nuevos campos:-ISSTART. Toma valor 1 si el punto es el punto inicial de la linea-LINEFID. El numero de linea de la que se ha extraido el punto</Abstract>
      </Parameter>
    </OutputParameters>
  </Process>
  <Process id="extractnodes">
    <Abstract></Abstract>
    <InputParameters>
      <Parameter id="LAYER">
        <Abstract></Abstract>
      </Parameter>
    </InputParameters>
    <OutputParameters>
      <Parameter id="RESULT">
        <Abstract></Abstract>
      </Parameter>
    </OutputParameters>
  </Process>
  <Process id="geometricproperties">
    <Abstract>This algorithm computes some geometric properties of the polygons in a given vector layer</Abstract>
    <InputParameters>
      <Parameter id="LAYER">
        <Abstract>The inputs polygons layer</Abstract>
      </Parameter>
    </InputParameters>
    <OutputParameters>
      <Parameter id="RESULT">
        <Abstract>The output layer is the same as the input one, but with the following fields added to its attributes table: AREA PERIMETER THICK = 4 x PI x AREA / PERIMETER^2 APRel = PERIMETER^2 / AREA APRel2 = 5 x PERIMETER / AREA QDR = 16 x AREA / (PERIMETER^2) FD = 2 x PERIMETER / log(AREA) RC = (4 x PI x AREA / PERIMETER^2)^0.5 SHAPE = PERIMETER / (2 x (AREA x PI)^0.5) = THICK^2</Abstract>
      </Parameter>
    </OutputParameters>
  </Process>
  <Process id="geometricpropertieslines">
    <Abstract>Este algoritmo calcula propiedades geometricas de las lineas de una capa de lineas.</Abstract>
    <InputParameters>
      <Parameter id="LINES">
        <Abstract>La capa de entrada</Abstract>
      </Parameter>
    </InputParameters>
    <OutputParameters>
      <Parameter id="RESULT">
        <Abstract>La capa resultante. Contiene las mismas geometrias que la capa de entrada, pero presenta cinco campos adicionales en su tabla de atributos:LongitudDistancia euclidea entre el primer y ultimo punto de la lineaSinuosidadAngulo medio entre segmentosOrientacion de la linea (Azimut de la recta entre el primer y ultimo punto de la linea)</Abstract>
      </Parameter>
    </OutputParameters>
  </Process>
  <Process id="geometriestopoints">
    <Abstract>This algorithm generates a new points layer, taking all nodes from an input vector layer.Attributes of each point are taken from the geometry it belongs to.</Abstract>
    <InputParameters>
      <Parameter id="INPUT">
        <Abstract>The input vector layer</Abstract>
      </Parameter>
    </InputParameters>
    <OutputParameters>
      <Parameter id="POINTS">
        <Abstract>The resulting points layer</Abstract>
      </Parameter>
    </OutputParameters>
  </Process>
  <Process id="intersection">
    <Abstract>This algorithm computes the intersection between two polygon vector layers. This is equivalent to a boolean AND operator. The geometries are altered and attributes table of the resulting layer contains as many fields as the union of both input attributes tables, as shown in the following picture</Abstract>
    <InputParameters>
      <Parameter id="LAYER1">
        <Abstract>The first input layer</Abstract>
      </Parameter>
      <Parameter id="LAYER2">
        <Abstract>The second input layer</Abstract>
      </Parameter>
    </InputParameters>
    <OutputParameters>
      <Parameter id="RESULT">
        <Abstract>The resulting output layer with intersected polygons and a modified attributes table</Abstract>
      </Parameter>
    </OutputParameters>
  </Process>
  <Process id="nodelines">
    <Abstract>Este algoritmo aade nodos en los cruces entre lineas, alli donde estos no existan. El efecto de este proceso puede verse claramente en la siguiente imagen.</Abstract>
    <InputParameters>
      <Parameter id="LINES">
        <Abstract>La capa de lineas a analizar.</Abstract>
      </Parameter>
    </InputParameters>
    <OutputParameters>
      <Parameter id="RESULT">
        <Abstract>La capa de lineas resultante, con nodos en todos sus cruces. La tabla de atributos es identica a la de la capa de entrada.</Abstract>
      </Parameter>
    </OutputParameters>
  </Process>
  <Process id="pointcoordinates">
    <Abstract>This algorithm takes a points layer and generates a new layer with those same points, but adding two new fields (X and Y) to its attributes table, containing X and Y coordinates of each point</Abstract>
    <InputParameters>
      <Parameter id="LAYER">
        <Abstract>The input points layer</Abstract>
      </Parameter>
    </InputParameters>
    <OutputParameters>
      <Parameter id="RESULT">
        <Abstract>The resulting layer with coordinates</Abstract>
      </Parameter>
    </OutputParameters>
  </Process>
  <Process id="polygonize">
    <Abstract></Abstract>
    <InputParameters>
      <Parameter id="LAYER">
        <Abstract></Abstract>
      </Parameter>
    </InputParameters>
    <OutputParameters>
      <Parameter id="RESULT">
        <Abstract></Abstract>
      </Parameter>
    </OutputParameters>
  </Process>
  <Process id="polygonstopolylines">
    <Abstract>This algorithms converts a polygons layer into a polylines layer</Abstract>
    <InputParameters>
      <Parameter id="LAYER">
        <Abstract>Polygons</Abstract>
      </Parameter>
    </InputParameters>
    <OutputParameters>
      <Parameter id="RESULT">
        <Abstract>Lines</Abstract>
      </Parameter>
    </OutputParameters>
  </Process>
  <Process id="polylinestopolygons">
    <Abstract>This algorithm converts polylines to polygons. Each polygon gets the attributes of the polyline it was created from.</Abstract>
    <InputParameters>
      <Parameter id="LAYER">
        <Abstract>The input lines layer.</Abstract>
      </Parameter>
    </InputParameters>
    <OutputParameters>
      <Parameter id="RESULT">
        <Abstract>The output polygons layer</Abstract>
      </Parameter>
    </OutputParameters>
  </Process>
  <Process id="polylinestosinglesegments">
    <Abstract>This algorithm takes a lines layer and generates a new lines layer where each line has been substituted by a single segment (a line with just two nodes), which best approximate the direction and shape of the input line.</Abstract>
    <InputParameters>
      <Parameter id="LINES">
        <Abstract>The input lines layer</Abstract>
      </Parameter>
    </InputParameters>
    <OutputParameters>
      <Parameter id="RESULT">
        <Abstract>The output layer, with single segments instead of complex lines.</Abstract>
      </Parameter>
    </OutputParameters>
  </Process>
  <Process id="removeholes">
    <Abstract>This algorithm removes holes from polygons in a polygon layer. A hole is an empty area within a polygon. Polygons with holes are defined as a envelope polygon (the outter contour) and a set of inner ones (the holes). This algorithm transform each polygon, removing those inner subpolygons and leaving just the outter one.</Abstract>
    <InputParameters>
      <Parameter id="LAYER">
        <Abstract>The input polygon layer</Abstract>
      </Parameter>
    </InputParameters>
    <OutputParameters>
      <Parameter id="RESULT">
        <Abstract>The resulting layer, with polygons with no holes. The attributes table is left unmodified</Abstract>
      </Parameter>
    </OutputParameters>
  </Process>
  <Process id="removerepeatedgeometries">
    <Abstract>Este algoritmo limpia una capa vectorial de cualquier tipo, eleminando aquellas geometrias que aparezcan duplicadas. El algoritmo solo comprueba las geometrias y no los valores de atributos asociados, de forma que si existen dos entidades con distintos atributos pero con una geometria identica, una de ellas sera eliminada.</Abstract>
    <InputParameters>
      <Parameter id="LAYER">
        <Abstract>La capa de entrada con geometrias duplicadas.</Abstract>
      </Parameter>
    </InputParameters>
    <OutputParameters>
      <Parameter id="RESULT">
        <Abstract>La capa de salida, sin geometrias duplicadas</Abstract>
      </Parameter>
    </OutputParameters>
  </Process>
  <Process id="splitmultipart">
    <Abstract>This algorithm separates those features that contains more than one single geometry.The resulting layer will contain each one of those geometries in a different feature. All features will share the same associated attributes</Abstract>
    <InputParameters>
      <Parameter id="INPUT">
        <Abstract>The input layer, containing multi-part features</Abstract>
      </Parameter>
    </InputParameters>
    <OutputParameters>
      <Parameter id="RESULT">
        <Abstract>The resulting layer, containing only single-part features.</Abstract>
      </Parameter>
    </OutputParameters>
  </Process>
  <Process id="splitpolylinesatnodes">
    <Abstract>Este algoritmo fragmenta una capa de polilineas, convirtiendola en otra con lineas sencillas.Cada entidad de la capa de entrada es fragmentada en n-1 segmentos, siendo n el numero de nodos de dicha linea. Todos esos segmentos tendran asociados los atributos de la linea a la que pertenecen.</Abstract>
    <InputParameters>
      <Parameter id="LINES">
        <Abstract>La capa de polilineas de entrada</Abstract>
      </Parameter>
    </InputParameters>
    <OutputParameters>
      <Parameter id="RESULT">
        <Abstract>La capa resultante, con segmentos simples.</Abstract>
      </Parameter>
    </OutputParameters>
  </Process>
  <Process id="symdifference">
    <Abstract></Abstract>
    <InputParameters>
      <Parameter id="LAYER">
        <Abstract></Abstract>
      </Parameter>
      <Parameter id="CLIPLAYER">
        <Abstract></Abstract>
      </Parameter>
    </InputParameters>
    <OutputParameters>
      <Parameter id="RESULT">
        <Abstract></Abstract>
      </Parameter>
    </OutputParameters>
  </Process>
  <Process id="union">
    <Abstract>La union es equivalente al operador logico OR (O), ya que la capa resultante mantiene todas las entidades en ambas capas de entrada (igual que la interseccion), y junto a estas, tambien aquellas zonas que aparecen unicamente en una de las capas de origen. Las entidades o geometrias han de ser de tipo poligono. Se genera una nueva capa de poligonos donde las geometrias se han dividido. De esta forma, y al unir dos capas de poligonos, encontraremos en la capa resultante zonas que estan cubiertas por uno de ellos perteneciente a la primera capa, o bien por uno de la segunda capa, o bien por poligonos de ambas capas. La tabla de atributos resultante contiene tantos campos como el conjunto de las dos capas de partida. </Abstract>
    <InputParameters>
      <Parameter id="LAYER1">
        <Abstract>primera capa de entrada.</Abstract>
      </Parameter>
      <Parameter id="LAYER2">
        <Abstract>segunda capa de entrada.</Abstract>
      </Parameter>
    </InputParameters>
    <OutputParameters>
      <Parameter id="RESULT">
        <Abstract>Capa uni�n</Abstract>
      </Parameter>
    </OutputParameters>
  </Process>
  <Process id="vectormean">
    <Abstract>This algorithm computes the directional mean of a set of lines in a vector layer. Each segment of the input lines is treated as a vector. Summing up all those vector, a new one showing the directional mean is obtained. This vector is represented as a single-segment line in the resulting vector layerThe modulus of the resulting vector provides information about the directional variance. Uniform directions will yield longer vectors. </Abstract>
    <InputParameters>
      <Parameter id="LINES">
        <Abstract>input line layer.</Abstract>
      </Parameter>
    </InputParameters>
    <OutputParameters>
      <Parameter id="RESULT">
        <Abstract>The vector layer with the directional mean vector. Its attributes table contains the following fields: mean distance angle (azimuth) circular variance.</Abstract>
      </Parameter>
    </OutputParameters>
  </Process>
  <Process id="clipbyrectangle">
    <Abstract>This algorithms clips a vector layer using a rectangular area defined by its max and min coordinates. Instead of using a second layer to define the clipping region, this is defined numerically by the user. Useful in scripting and batch mode.</Abstract>
    <InputParameters>
      <Parameter id="LAYER">
        <Abstract>The vector layer to clip</Abstract>
      </Parameter>
      <Parameter id="XMIN">
        <Abstract>Minimum X coordinate of the clipping region</Abstract>
      </Parameter>
      <Parameter id="XMAX">
        <Abstract>Maximum X coordinate of the clipping region</Abstract>
      </Parameter>
      <Parameter id="YMIN">
        <Abstract>Minimum Y coordinate of the clipping region</Abstract>
      </Parameter>
      <Parameter id="YMAX">
        <Abstract>Maximum Y coordinate of the clipping region</Abstract>
      </Parameter>
    </InputParameters>
    <OutputParameters>
      <Parameter id="RESULT">
        <Abstract>The clipped layer, which will contain geometries only within the defined boundary rectangle</Abstract>
      </Parameter>
    </OutputParameters>
  </Process>
  <Process id="groupnearfeatures">
    <Abstract>Este algoritmo agrupa (clasifica) entidades a una distancia proxima. Para ello, crea una copia de la capa vectorial de entrada y asigna a cada entidad un numero en el atributo 'GROUP_ID' dependiendo de su pertenencia a un grupo u otro. El algoritmo requiere como parametro de entrada un valor de tolerancia que determinaran la zona de influencia de las agrupaciones. El numero resultante de grupos (clases) no es un parametro seleccionable por el usuario, sino que el algoritmo lo calcula de forma dinamica en tiempo de ejecucion.</Abstract>
    <InputParameters>
      <Parameter id="LAYER">
        <Abstract>La capa de entrada a agrupar</Abstract>
      </Parameter>
      <Parameter id="TOLERANCE">
        <Abstract>Distancia de zona de influencia de los grupos</Abstract>
      </Parameter>
    </InputParameters>
    <OutputParameters>
      <Parameter id="RESULT">
        <Abstract>La capa de salida con un campo 'GROUP_ID'</Abstract>
      </Parameter>
    </OutputParameters>
  </Process>
  <Process id="joinadjacentlines">
    <Abstract>Este algoritmo une subtramos de lineas recogidos en geometrias distintas, en una unica geometria. Para ello, se sirve de una tolerancia establecida por el usuario, de forma que dos geometrias se consideran parte de una misma linea si el punto final de la primera y el inicial de la segunda estan a una distancia menor que dicha tolarancia.Para que, situandose a una distancia menor de la tolerancia, dos lineas se unan, tienen que estar digitalizadas en el mismo sentido. Si la linea resultante esta formada por mas de dos lLa linea resultante de la union tiene asociados los atributos de la primera sub-geometria, siendo esta la primera en el sentido en el que se encuentran digitalizadas.</Abstract>
    <InputParameters>
      <Parameter id="LAYER">
        <Abstract>La capa con los tramos de lineas a unir</Abstract>
      </Parameter>
      <Parameter id="TOLERANCE">
        <Abstract>La distancia maxima para considerar que dos lineas deben unirse. Esta es la distancia maxima que debe existir entre los puntos inicial y final de ambas lineas.</Abstract>
      </Parameter>
    </InputParameters>
    <OutputParameters>
      <Parameter id="RESULT">
        <Abstract>La capa con las lineas unidas.</Abstract>
      </Parameter>
    </OutputParameters>
  </Process>
  <Process id="linestoequispacedpoints">
    <Abstract>This algorithm creates a new points layer by adding evenly spaced points along the lines of an input layer</Abstract>
    <InputParameters>
      <Parameter id="LINES">
        <Abstract>the input lines layer.</Abstract>
      </Parameter>
      <Parameter id="DISTANCE">
        <Abstract>Distance between points, measured along the line.</Abstract>
      </Parameter>
    </InputParameters>
    <OutputParameters>
      <Parameter id="RESULT">
        <Abstract>The attributes table of this output layer contains the same fields as the one associated to the input layer. Each point is given the values of the line it belongs to</Abstract>
      </Parameter>
    </OutputParameters>
  </Process>
  <Process id="perturbatepointslayer">
    <Abstract>This algorithm alter the position of points in a layer, displacing them. Points are displaced in a random direction, and the displacement distance follows a normal distribution.</Abstract>
    <InputParameters>
      <Parameter id="LAYER">
        <Abstract>The input points layer</Abstract>
      </Parameter>
      <Parameter id="MEAN">
        <Abstract>The mean displacement distance</Abstract>
      </Parameter>
      <Parameter id="STDDEV">
        <Abstract>The standard deviation of the displacement distance</Abstract>
      </Parameter>
    </InputParameters>
    <OutputParameters>
      <Parameter id="RESULT">
        <Abstract>Resultado</Abstract>
      </Parameter>
    </OutputParameters>
  </Process>
  <Process id="snappoints">
    <Abstract>This algorithm snaps points in a given layer to the lines in a second one</Abstract>
    <InputParameters>
      <Parameter id="LAYER">
        <Abstract>The input points layer</Abstract>
      </Parameter>
      <Parameter id="SNAPTO">
        <Abstract>the input lines layer</Abstract>
      </Parameter>
      <Parameter id="TOLERANCE">
        <Abstract>The maximum snapping distance. If distance from a point to the closest line is lower than this tolerance, the point will be snapped to that line.</Abstract>
      </Parameter>
    </InputParameters>
    <OutputParameters>
      <Parameter id="RESULT">
        <Abstract>The resulting points layer</Abstract>
      </Parameter>
    </OutputParameters>
  </Process>
  <Process id="transform">
    <Abstract>This algorithm applies a affine transformation to all the geometries of a given vector layer.</Abstract>
    <InputParameters>
      <Parameter id="LAYER">
        <Abstract>The layer to transform</Abstract>
      </Parameter>
      <Parameter id="DISTANCEX">
        <Abstract>The distance for translation along the X axis</Abstract>
      </Parameter>
      <Parameter id="DISTANCEY">
        <Abstract>The distance for translation along the Y axis</Abstract>
      </Parameter>
      <Parameter id="ANGLE">
        <Abstract>The angle to rotate geometries</Abstract>
      </Parameter>
      <Parameter id="SCALEX">
        <Abstract>The scale factor along the X axis</Abstract>
      </Parameter>
      <Parameter id="SCALEY">
        <Abstract>The scale factor along the X axis</Abstract>
      </Parameter>
      <Parameter id="ANCHORX">
        <Abstract>The X coordinate of the location of the anchor point for rotation</Abstract>
      </Parameter>
      <Parameter id="ANCHORY">
        <Abstract>The X coordinate of the location of the anchor point for rotation</Abstract>
      </Parameter>
    </InputParameters>
    <OutputParameters>
      <Parameter id="RESULT">
        <Abstract>The transformed layer.</Abstract>
      </Parameter>
    </OutputParameters>
  </Process>
  <Process id="vectorspatialcluster">
    <Abstract>This algorithm creates clusters from an input points layer, grouping them according to their spatial location.</Abstract>
    <InputParameters>
      <Parameter id="LAYER">
        <Abstract>The input points layer</Abstract>
      </Parameter>
      <Parameter id="NUMCLASS">
        <Abstract>The desired number of clusters</Abstract>
      </Parameter>
    </InputParameters>
    <OutputParameters>
      <Parameter id="RESULT">
        <Abstract>The resulting layer is identical to the input one, but contains an additional field in its attributes table, which indicates the group each point belongs to.</Abstract>
      </Parameter>
    </OutputParameters>
  </Process>
  <Process id="fixeddistancebuffer">
    <Abstract>This algorithm creates a new polygon layer with buffers around features in the input layer. All buffers will have the same size, regardless of the feature being buffered.</Abstract>
    <InputParameters>
      <Parameter id="LAYER">
        <Abstract>The layer with features to buffer</Abstract>
      </Parameter>
      <Parameter id="DISTANCE">
        <Abstract>The distance that defines the size of buffers to be created</Abstract>
      </Parameter>
      <Parameter id="TYPES">
        <Abstract>The following methods are available Inside the polygon:  Inside and outside the polygon:  Outside the polygon: </Abstract>
        <SelectionValue id="BUFFER_OUTSIDE_POLY" value="0" />
        <SelectionValue id="BUFFER_INSIDE_POLY" value="1" />
        <SelectionValue id="BUFFER_INSIDE_OUTSIDE_POLY"
          value="2" />
      </Parameter>
      <Parameter id="RINGS">
        <Abstract>The number of concentric rings to create (from 1 to 3)</Abstract>
        <SelectionValue id="NUMBER_OF_RINGS" value="0-2" />
      </Parameter>
      <Parameter id="NOTROUNDED">
        <Abstract>If selected, resulting polygons will not be rounded</Abstract>
      </Parameter>
    </InputParameters>
    <OutputParameters>
      <Parameter id="RESULT">
        <Abstract>The resulting buffer layer</Abstract>
      </Parameter>
    </OutputParameters>
  </Process>
  <Process id="generateroutes">
    <Abstract>This algorithm creates a number of new alternative routes based on an original route, linking the same starting and end points.</Abstract>
    <InputParameters>
      <Parameter id="ROUTE">
        <Abstract>the original route layer. If the layer has many lines, the first line is taken.</Abstract>
      </Parameter>
      <Parameter id="NROUTES">
        <Abstract>Number of new routes</Abstract>
      </Parameter>
      <Parameter id="METHOD">
        <Abstract>to choose between: Constrained brownian motion Recombination</Abstract>
        <SelectionValue id="CREATION_METHOD_BROWNIAN_(doesn't work)"
          value="0" />
        <SelectionValue id="CREATION_METHOD_RECOMBINE_(works)"
          value="1" />
      </Parameter>
      <Parameter id="SINUOSITY">
        <Abstract>relation between the total distance and the euclidian distance for the result lines if the constrained brownian motion is used.</Abstract>
      </Parameter>
      <Parameter id="USESINUOSITY">
        <Abstract>if this is selected, the above field will not have any effect and the sinousity of the base route will be applied.</Abstract>
      </Parameter>
    </InputParameters>
    <OutputParameters>
      <Parameter id="RESULT">
        <Abstract>Routes</Abstract>
      </Parameter>
    </OutputParameters>
  </Process>
  <Process id="simplifylines">
    <Abstract>This algorithm simplifies lines, reducing the number of vertices in each of them,</Abstract>
    <InputParameters>
      <Parameter id="LAYER">
        <Abstract>Lines</Abstract>
      </Parameter>
      <Parameter id="TOLERANCE">
        <Abstract>Tolerance</Abstract>
      </Parameter>
      <Parameter id="PRESERVE">
        <Abstract>Selecting this option will preserve the topology of the original lines layer .</Abstract>
      </Parameter>
    </InputParameters>
    <OutputParameters>
      <Parameter id="RESULT">
        <Abstract>New lines vector layer with the name of the origin layer.</Abstract>
      </Parameter>
    </OutputParameters>
  </Process>
  <Process id="simplifypolygons">
    <Abstract>This algorithm simplifies points, removing nodes from them. This reduces the amount of data needed to store a polygon, while preserving its original shape as much as possible. The number of nodes removed depends on a tolerance value.</Abstract>
    <InputParameters>
      <Parameter id="LAYER">
        <Abstract>The input layer with polygons to simplify</Abstract>
      </Parameter>
      <Parameter id="TOLERANCE">
        <Abstract>The tolerance to use. Larger values will yield more simplified polygons (a larger number of points will be removed)</Abstract>
      </Parameter>
      <Parameter id="PRESERVE">
        <Abstract>If selected, the algorithm will preserve the topology.</Abstract>
      </Parameter>
    </InputParameters>
    <OutputParameters>
      <Parameter id="RESULT">
        <Abstract>The output layer with simplified polygons. The attributes table is left unaltered.</Abstract>
      </Parameter>
    </OutputParameters>
  </Process>
  <Process id="smoothlines">
    <Abstract>simplify lines</Abstract>
    <InputParameters>
      <Parameter id="LAYER">
        <Abstract>The input lines layer</Abstract>
      </Parameter>
      <Parameter id="INTERMEDIATE_POINTS">
        <Abstract>The nummer of intermediate points to add. A larger value will cause the algorithm to add more points, resulting in a more smooth line, but enlarging the size of the resulting file.</Abstract>
        <SelectionValue id="NUMBER_OF_POINTS" value="1-10" />
      </Parameter>
      <Parameter id="CURVE_TYPE">
        <Abstract>The type of mathematical curve to use for the smoothing</Abstract>
        <SelectionValue id="NATURAL_CUBIC_SPLINES" value="0" />
        <SelectionValue id="BEZIER_CURVES" value="1" />
        <SelectionValue id="BSPLINES" value="2" />
      </Parameter>
    </InputParameters>
    <OutputParameters>
      <Parameter id="RESULT">
        <Abstract>The resulting layer with smoothed lines.</Abstract>
      </Parameter>
    </OutputParameters>
  </Process>
  <Process id="splitlineswithpoints">
    <Abstract>This algorithm splits a lines layer using an additional points layer.Points at a distance from a line lower than a given threshold will cause the be splitted at the closest point between both. A value from the point is added to the line. The user can select whether to add it to the segment finishing at the point or to the one starting at it</Abstract>
    <InputParameters>
      <Parameter id="LINES">
        <Abstract>The input lines layer</Abstract>
      </Parameter>
      <Parameter id="POINTS">
        <Abstract>Points used to split lines in the input lines layer</Abstract>
      </Parameter>
      <Parameter id="TOLERANCE">
        <Abstract>Threshold distance for splitting</Abstract>
      </Parameter>
      <Parameter id="METHOD">
        <Abstract>The following methods are available: Add data before point. Add data after point.</Abstract>
        <SelectionValue id="START_VALUE" value="0" />
        <SelectionValue id="LAST_VALUE" value="1" />
      </Parameter>
    </InputParameters>
    <OutputParameters>
      <Parameter id="RESULT">
        <Abstract>The output layer with splitted lines.</Abstract>
      </Parameter>
    </OutputParameters>
  </Process>
  <Process id="vectoraddfield">
    <Abstract>Este algoritmo aade un nuevo campo a la tabla de atributos de una capa vectorial</Abstract>
    <InputParameters>
      <Parameter id="INPUT">
        <Abstract>La capa en cuya tabla de atributos se quiere aadir un nuevo campo</Abstract>
      </Parameter>
      <Parameter id="FIELD_NAME">
        <Abstract>El nombre del campo a aadir</Abstract>
      </Parameter>
      <Parameter id="FIELD_TYPE">
        <Abstract>El tipo de campo que se desea aadir, a elegir entre las siguiente opciones:</Abstract>
        <SelectionValue id="INTEGER" value="0" />
        <SelectionValue id="DOUBLE" value="1" />
        <SelectionValue id="STRING" value="2" />
      </Parameter>
      <Parameter id="FIELD_LENGTH">
        <Abstract>El tamao del campo</Abstract>
      </Parameter>
      <Parameter id="FIELD_PRECISION">
        <Abstract>La precision (numero de cifras decimales) en el caso de que el campo sea de tipo Double</Abstract>
      </Parameter>
      <Parameter id="DEFAULT_VALUE">
        <Abstract>Valor por defecto. Una vez creado el campo, se rellenara con ese valor para todas las entidades.</Abstract>
      </Parameter>
    </InputParameters>
    <OutputParameters>
      <Parameter id="RESULT">
        <Abstract>La capa vectorial resultante, con las mismas geometrias que la capa de entrada y una tabla de atributos extendida con el campo definido y el valor por defecto establecido.</Abstract>
      </Parameter>
    </OutputParameters>
  </Process>
  <Process id="vectorcluster">
    <Abstract>This algorithm classifies features in a vector layer into a given number of classes, using the values of a variable associated with those features.</Abstract>
    <InputParameters>
      <Parameter id="LAYER">
        <Abstract>The input layer with features to classified.</Abstract>
      </Parameter>
      <Parameter id="FIELDS">
        <Abstract>The field with the variable to be used for classification </Abstract>
      </Parameter>
      <Parameter id="NUMCLASS">
        <Abstract>The desired number of classes</Abstract>
      </Parameter>
    </InputParameters>
    <OutputParameters>
      <Parameter id="RESULT">
        <Abstract>The resulting layer is identical to the input one, but contains an additional field in its attributes table, which indicates the group each point belongs to.</Abstract>
      </Parameter>
    </OutputParameters>
  </Process>
  <Process id="vectorfieldcalculator">
    <Abstract>La extension Calculadora de campos permite realizar operaciones algebraicas con los atributos alfanumericos de capas vectoriales, obteniendo informacion derivada en forma de nuevas capas de datos geograficos.En la parte izquierda de la ventana aparecen todos los elementos que pueden ser seleccionados: campos, funciones, operadores, constantes. Los campos varian en funcion de la capa seleccionada.Haciendo doble click sobre un elemento en cuesti[AND-SYMBOL]oacute;n se a[AND-SYMBOL]ntilde;ade al cuadro de texto Expresi[AND-SYMBOL]oacute;n.Por ejemplo, para a[AND-SYMBOL]ntilde;adir un campo a la f[AND-SYMBOL]oacute;rmula,simplemente desplegar el elemento Campos y hacer doble click sobre el campo seleccionada. Tambi[AND-SYMBOL]eacute;n pueden teclearse directamente sobre dicho cuadro de texto las distintas expresiones y valores (ver m[AND-SYMBOL]aacute;s abajo sobre sintaxis general).       En la parte derecha de la ventana aparecen por un lado los operadores m[AND-SYMBOL]aacute;s habituales de c[AND-SYMBOL]aacute;lculo, y por otro lado los distintos botones de selecci[AND-SYMBOL]oacute;n de n[AND-SYMBOL]uacute;meros.</Abstract>
    <InputParameters>
      <Parameter id="LAYER">
        <Abstract>La capa que se desea ampliar con los resultados del calculo, y de cuyos campos se tomaran los valores para este.</Abstract>
      </Parameter>
      <Parameter id="FORMULA">
        <Abstract>La formula a utilizar. Los campos se introducen con su nombre, que es el que aparece en la cabecera de la tabla correspondientePueden emplearse las siguiente funciones: sin(x): devuelve el seno de x (x debe estar en radianes). cos(x): devuelve el coseno de x (x debe estar en radianes). tan(x): devuelve la tangente de x (x debe estar en radianes). asin(x): devuelve el arcoseno de x (x debe estar en radianes). acos(x): devuelve el arcocoseno de x (x debe estar en radianes). atan(x): devuelve la arcotangente de x (x debe estar en radianes). atan2(x/y): devuelve la arcotangente de x/y (x/y debe estar en radianes). sinh(x): devuelve el seno hiperbolico de x (x debe estar en radianes). cosh(x): devuelve el coseno hiperbolico de x (x debe estar en radianes). atanh(x): devuelve la tangente hiperbolica inversa de x (x debe estar en radianes). In(x): devuelve el logaritmo neperiano de x. log(x): devuelve el logaritmo en base 10. exp(x): devuelve la funcion exponencial de x. abs(x): devuelve el valor absoluto de x. rand(): devuelve un valor aleatorio en coma flotante, en el rango 0 a 1.0. mod(x/y): devuelve el modulo de x/y. sqrt(x): devuelve la raiz cuadrada no negativa de x. if(): devuelve 1 si es verdadera la expresion dentro del parentesis, 0  en caso contrario.Los siguientes operadores pueden emplearse, y la precedencia de operadores es la habitual : suma y resta se evaluan tras multiplicacion y division, y estos despues del operador de potencia. Usar parentesis en caso de duda, para estar seguro de como el programa evaluara la formula introducida. + (suma - (resta) (multiplicacion) / (divison)  [PERCENT-SYMBOL] (porcentaje) ! (NOT)  ^ (elevado a) [AND-SYMBOL][AND-SYMBOL] (AND) || (OR) [ (menor que) ] (mayor que) [= (menor o igual que) ]= (mayor o igual que)  == (igual a) != (distinto de)</Abstract>
      </Parameter>
    </InputParameters>
    <OutputParameters>
      <Parameter id="RESULT">
        <Abstract>con nuevos campos de atributos.</Abstract>
      </Parameter>
    </OutputParameters>
  </Process>


</SextanteProcesses>