se/SE/superedit-OPEN_LAYERS_WPS.php

<?php

/**
 * http://openlayers.org/dev/examples/wps.html
 * http://geoinformatyka.com.pl/usluga-wfs-jak-to-dziala/
 * 
 * TODO: brak ModifyFeature - html btn: olControlModifyFeatureItemInactive
 */

function OPEN_LAYERS_WPS() {

	$task = V::get('task', '', $_GET);
	switch ($task) {
		case 'proxy':
			$url = V::get('url', '', $_GET);
			// 1. http%3A%2F%2Fbiuro.biall-net.pl%2Fwps%3FSERVICE%3DWPS%26REQUEST%3DGetCapabilities
			// 2. http%3A%2F%2Fbiuro.biall-net.pl%2Fwps%3FSERVICE%3DWPS%26REQUEST%3DDescribeProcess%26VERSION%3D1.0.0%26IDENTIFIER%3Dpozdrawiam
			header('Content-Type: application/xml; charset=utf-8');
			$urlParts = parse_url($url);
			$urlQuery = array();
			$urlQueryTmp = V::get('query', '', $urlParts);
			$urlQueryTmp = explode('&', $urlQueryTmp);
			foreach ($urlQueryTmp as $vQuery) {
				$parts = explode('=', $vQuery, 2);
				$urlQuery[$parts[0]] = $parts[1];
			}

			if ('WPS' == V::get('SERVICE', '', $urlQuery)) {
				$req = V::get('REQUEST', '', $urlQuery);
				$wps = new WpsServer();
				$methodName = "{$req}Action";
				if (method_exists($wps, $methodName)) {
					$wps->$methodName($urlQuery);
				}
			}
			exit;
			break;
		default:
			
	}
	

//$_POST['url'] = 'http://demo.opengeo.org/geoserver/wfs';
//$entityBody = file_get_contents('php://input');
	$url = V::get('_url', '', $_GET);
	if ($url) {// @see OpenLayers/examples/proxy.cgi
		$allowedHosts = array('www.openlayers.org', 'openlayers.org', 
										'labs.metacarta.com', 'world.freemap.in', 
										'prototype.openmnnd.org', 'geo.openplans.org',
										'sigma.openplans.org', 'demo.opengeo.org',
										'www.openstreetmap.org', 'sample.azavea.com',
										'v2.suite.opengeo.org', 'v-swe.uni-muenster.de:8080',
										'vmap0.tiles.osgeo.org', 'www.openrouteservice.org',
										'maps.wien.gv.at');

		if (!empty($_POST)) {
			//	qs = os.environ["QUERY_STRING"]
			//	d = cgi.parse_qs(qs)
			//	if d.has_key("url"):
			//			url = d["url"][0]
			//	else:
			//			url = "http://www.openlayers.org"
		}
		else {
			//	fs = cgi.FieldStorage()
			//	url = fs.getvalue('url', "http://www.openlayers.org")
		}

		$host = explode('/', $url);
		$host = $host[2];
		if (!in_array($host, $allowedHosts)) {
			header("Status: 502 Bad Gateway");
			header("Content-Type: text/plain");
			echo "\nThis proxy does not allow you to access that location ({$host}).";
			exit;
		}
		else if (substr($url, 0, 7) == 'http://' || substr($url, 0, 8) == 'https://') {
			$ch = curl_init(); 
			
			if (!empty($_POST)) {
/*
            length = int(os.environ["CONTENT_LENGTH"])
            headers = {"Content-Type": os.environ["CONTENT_TYPE"]}
            body = sys.stdin.read(length)
            r = urllib2.Request(url, body, headers)
            y = urllib2.urlopen(r)
 */
			}
			else {
				curl_setopt($ch, CURLOPT_URL, $url);

				curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);// return the transfer as a string
				//curl_setopt($ch, CURLOPT_VERBOSE, 1);
				curl_setopt($ch, CURLOPT_HEADER, 1);

				$response = curl_exec($ch);

				// Then, after your curl_exec call:
				$header_size = curl_getinfo($ch, CURLINFO_HEADER_SIZE);
				$header = substr($response, 0, $header_size);
				$body = substr($response, $header_size);
				curl_close($ch);

				$contentType = 'text/plain';
				$headers = explode("\n", $header);
				foreach ($headers as $vHeader) {
					if (substr($vHeader, 0, 13) == 'Content-Type:') {
						$contentType = trim(substr($vHeader, 14));
					}
				}

				header("Content-Type: {$contentType}");
				echo $body . "\n";
			}
		}
		else {
			header("Content-Type: text/plain");
			echo "\nIllegal request.";
			exit;
		}
		exit;
	}

	?>
    <link rel="stylesheet" href="stuff/open-layers/theme/default/style.css" type="text/css">
    <link rel="stylesheet" href="stuff/open-layers/style.css" type="text/css">
    <style type="text/css">
        .olControlEditingToolbar .olControlModifyFeatureItemInactive {
            background-image: url(stuff/open-layers/theme/default/img/draw_point_off.png);
        }
        .olControlEditingToolbar .olControlModifyFeatureItemActive {
            background-image: url(stuff/open-layers/theme/default/img/draw_point_on.png);
        }
        textarea {
            display: block;
            width: 100%;
            height: 3em;
        }
        label {
            display: block;
        }
        .notsupported {
            color: red;
        }
        button {
            display: block;
            margin-top: 10px;
        }
        #docs {
            top: 6em;
            left: 550px;
            position: absolute;
            margin-right: 10px;
        }
    </style>

    <h1 id="title">WPS Builder Example</h1>

    <div id="tags">
        wps, process, advanced
    </div>

    <div id="shortdesc">Using WPS formats to interact with WPS</div>

    <div id="docs">
        <p>This example shows WPS in action by using the WPSCapabilities,
        WPSDescribeProcess and WPSExecute formats. See
        <a target="_blank" href="wps.js">wps.js</a> for the
        source code. <b>Note: For applications using WPS, the high level
        approach shown in the <a href="wps-client.html">wps-client</a> example
        is recommended instead.</b></p>
        <ol>
            <li>Select a process from the list below the map. The list is
            populated with the result of a WPS GetCapabilities request, parsed
            using <code>OpenLayers.Format.WPSCapabilities::read</code>.</li>
            <li>Fill out the Input form. Hover over fields to get a description.
            Required fields are marked with a "*".
            To use a geometry from the map as input, select the geometry on the
            map (using the pen symbol on the left of the toolbar) and just
            click the field. The form is generated from the object returned by
            <code>OpenLayers.Format.WPSDescribeProcess::read</code></li>
            <li>Click "Execute" and examine the result in the result text area.
            If the result can be parsed as features, it will be displayed on
            the map as well. The process data is sent to the server with the
            serialized XML from <code>OpenLayers.Format.WPSExecute::write</code>,
            which can use a modified
            <code>OpenLayers.Format.WPSDescribeProcess</code> result object as
            input.</li>
        </ol>
    </div>

    <div id="example" style="width:520px">
        <div id="map" class="smallmap"></div>

        <div>
            <select id="processes"><option>Select a process</option></select>
            <p id="abstract"></p>
            <div id="input"></div>
            <div id="output"></div>
        </div>
    </div>
    <script src="stuff/open-layers/lib/OpenLayers.js"></script>
<!--    <script src="stuff/open-layers/wps.js"></script> -->
    <script>
//OpenLayers.ProxyHost = "proxy.cgi?url=";
//OpenLayers.ProxyHost = "index.php?FUNCTION_INIT=OPEN_LAYERS_WPS&HEADER_NOT_INIT=YES&_url=";
OpenLayers.ProxyHost = "index.php?FUNCTION_INIT=<?php echo __FUNCTION__; ?>&HEADER_NOT_INIT=YES&task=proxy&url=";

var wps = 'http://biuro.biall-net.pl/wps',//"http://demo.opengeo.org/geoserver/wps",
    capabilities, // the capabilities, read by Format.WPSCapabilities::read
    process; // the process description from Format.WPSDescribeProcess::read

// get some capabilities
getCapabilities();

// create the UI
var layer = new OpenLayers.Layer.Vector("Scratchpad");

/*
var saveStrategy = new OpenLayers.Strategy.Save();
var wfsLayer = new OpenLayers.Layer.Vector("Editable Features", {
        strategies: [new OpenLayers.Strategy.BBOX(), saveStrategy],
        projection: new OpenLayers.Projection("EPSG:4326"),
        protocol: new OpenLayers.Protocol.WFS({
            version: "1.1.0",
            srsName: "EPSG:4326",
            url: "http://demo.opengeo.org/geoserver/wfs",
            featureNS :  "http://opengeo.org",
            featureType: "restricted",
            geometryName: "the_geom",
            schema: "http://demo.opengeo.org/geoserver/wfs/DescribeFeatureType?version=1.1.0&typename=og:restricted",
            outputFormat: 'json'
        })
    }); 
*/

var toolbar = new OpenLayers.Control.EditingToolbar(layer);
toolbar.addControls([new OpenLayers.Control.ModifyFeature(layer, {
    title: "Select feature"
})]);
var map = new OpenLayers.Map('map', {
    controls: [
        toolbar,
        new OpenLayers.Control.ZoomPanel(),
        new OpenLayers.Control.PanPanel()
    ],
    layers: [
        new OpenLayers.Layer.WMS(
            "OSM", "http://maps.opengeo.org/geowebcache/service/wms",
            {layers: "openstreetmap", format: "image/png"}
        ),
        layer
 //       , wfsLayer
    ]
});
map.zoomToMaxExtent();

// add behavior to html elements
document.getElementById("processes").onchange = describeProcess;

// using OpenLayers.Format.WPSCapabilities to read the capabilities
function getCapabilities() {
    OpenLayers.Request.GET({
        url: wps,
        params: {
            "SERVICE": "WPS",
            "REQUEST": "GetCapabilities"
        },
        success: function(response){
            capabilities = new OpenLayers.Format.WPSCapabilities().read(
                response.responseText
            );
            var dropdown = document.getElementById("processes");
            var offerings = capabilities.processOfferings, option;
            // populate the dropdown
            for (var p in offerings) {
                option = document.createElement("option");
                option.innerHTML = offerings[p].identifier;
                option.value = p;
                dropdown.appendChild(option);
            }
        }
    });
}

// using OpenLayers.Format.WPSDescribeProcess to get information about a
// process
function describeProcess() {
    var selection = this.options[this.selectedIndex].value;
    OpenLayers.Request.GET({
        url: wps,
        params: {
            "SERVICE": "WPS",
            "REQUEST": "DescribeProcess",
            "VERSION": capabilities.version,
            "IDENTIFIER": selection
        },
        success: function(response) {
            process = new OpenLayers.Format.WPSDescribeProcess().read(
                response.responseText
            ).processDescriptions[selection];
            buildForm();
        }
    });
}

// dynamically create a form from the process description
function buildForm() {
    document.getElementById("abstract").innerHTML = process["abstract"];
    document.getElementById("input").innerHTML = "<h3>Input:</h3>";
    document.getElementById("output").innerHTML = "";

    var inputs = process.dataInputs, supported = true,
        sld = "text/xml; subtype=sld/1.0.0",
        input;
    for (var i=0,ii=inputs.length; i<ii; ++i) {
        input = inputs[i];
        if (input.complexData) {
            var formats = input.complexData.supported.formats;
            if (formats["application/wkt"]) {
                addWKTInput(input);
            } else if (formats["text/xml; subtype=wfs-collection/1.0"]) {
                addWFSCollectionInput(input);
            } else if (formats["image/tiff"]) {
                addRasterInput(input);
            } else if (formats[sld]) {
                addXMLInput(input, sld);
            } else {
                supported = false;
            }
        } else if (input.boundingBoxData) {
            addBoundingBoxInput(input);
        } else if (input.literalData) {
            addLiteralInput(input);
        } else {
            supported = false;
        }
        if (input.minOccurs > 0) {
            document.getElementById("input").appendChild(document.createTextNode("* "));
        }
    }
    
    if (supported) {
        var executeButton = document.createElement("button");
        executeButton.innerHTML = "Execute";
        document.getElementById("input").appendChild(executeButton);
        executeButton.onclick = execute;
    } else {
        document.getElementById("input").innerHTML = '<span class="notsupported">' +
            "Sorry, the WPS builder does not support the selected process." +
            "</span>";
    }
}

// helper function to dynamically create a textarea for geometry (WKT) data
// input
function addWKTInput(input, previousSibling) {
    var name = input.identifier;
    var container = document.getElementById("input");
    var label = document.createElement("label");
    label["for"] = name;
    label.title = input["abstract"];
    label.innerHTML = name + " (select feature, then click field):";
    previousSibling && previousSibling.nextSibling ?
        container.insertBefore(label, previousSibling.nextSibling) :
        container.appendChild(label);
    var field = document.createElement("textarea");
    field.onclick = function () {
        if (layer.selectedFeatures.length) {
            this.innerHTML = new OpenLayers.Format.WKT().write(
                layer.selectedFeatures[0]
            );
        }
        createCopy(input, this, addWKTInput);
    };
    field.onblur = function() {
        input.data = field.value ? {
            complexData: {
                mimeType: "application/wkt",
                value: this.value
            }
        } : undefined;
    };
    field.title = input["abstract"];
    field.id = name;
    previousSibling && previousSibling.nextSibling ?
        container.insertBefore(field, previousSibling.nextSibling.nextSibling) :
        container.appendChild(field);
}

// helper function for xml input
function addXMLInput(input, type) {
    var name = input.identifier;
    var field = document.createElement("input");
    field.title = input["abstract"];
    field.value = name + " (" + type + ")";
    field.onblur = function() {
        input.data = field.value ? {
            complexData: {
                mimeType: type,
                value: this.value
            }
        } : undefined;
    };
    document.getElementById("input").appendChild(field);
}

// helper function to dynamically create a WFS collection reference input
function addWFSCollectionInput(input) {
    var name = input.identifier;
    var field = document.createElement("input");
    field.title = input["abstract"];
    field.value = name + " (layer on demo server)";
    addValueHandlers(field, function() {
        input.reference = field.value ? {
            mimeType: "text/xml; subtype=wfs-collection/1.0",
            href: "http://geoserver/wfs",
            method: "POST",
            body: {
                wfs: {
                    version: "1.0.0",
                    outputFormat: "GML2",
                    featureType: field.value
                }
            }
        } : undefined;
    });
    document.getElementById("input").appendChild(field);
}

// helper function to dynamically create a raster (GeoTIFF) url input
function addRasterInput(input) {
    var name = input.identifier;
    var field = document.createElement("input");
    field.title = input["abstract"];
    var url = window.location.href.split("?")[0];
    field.value = url.substr(0, url.lastIndexOf("/")+1) + "data/tazdem.tiff";
    document.getElementById("input").appendChild(field);
    (field.onblur = function() {
        input.reference = {
            mimeType: "image/tiff",
            href: field.value,
            method: "GET"
        };
    })();
}

// helper function to dynamically create a bounding box input
function addBoundingBoxInput(input) {
    var name = input.identifier;
    var field = document.createElement("input");
    field.title = input["abstract"];
    field.value = "left,bottom,right,top (EPSG:4326)";
    document.getElementById("input").appendChild(field);
    addValueHandlers(field, function() {
        input.boundingBoxData = {
            projection: "EPSG:4326",
            bounds: OpenLayers.Bounds.fromString(field.value)
        };
    });
}

// helper function to create a literal input textfield or dropdown
function addLiteralInput(input, previousSibling) {
    var name = input.identifier;
    var container = document.getElementById("input");
    var anyValue = input.literalData.anyValue;
    // anyValue means textfield, otherwise we create a dropdown
    var field = document.createElement(anyValue ? "input" : "select");
    field.id = name;
    field.title = input["abstract"];
    previousSibling && previousSibling.nextSibling ?
        container.insertBefore(field, previousSibling.nextSibling) :
        container.appendChild(field);
    if (anyValue) {
        var dataType = input.literalData.dataType;
        field.value = name + (dataType ? " (" + dataType + ")" : "");
        addValueHandlers(field, function() {
            input.data = field.value ? {
                literalData: {
                    value: field.value
                }
            } : undefined;
            createCopy(input, field, addLiteralInput);
        });
    } else {
        var option;
        option = document.createElement("option");
        option.innerHTML = name;
        field.appendChild(option);
        for (var v in input.literalData.allowedValues) {
            option = document.createElement("option");
            option.value = v;
            option.innerHTML = v;
            field.appendChild(option);
        }
        field.onchange = function() {
            createCopy(input, field, addLiteralInput);
            input.data = this.selectedIndex ? {
                literalData: {
                    value: this.options[this.selectedIndex].value
                }
            } : undefined;
        };
    }
}

// if maxOccurs is > 1, this will add a copy of the field
function createCopy(input, field, fn) {
    if (input.maxOccurs && input.maxOccurs > 1 && !field.userSelected) {
        // add another copy of the field - we don't check maxOccurs
        field.userSelected = true;
        var newInput = OpenLayers.Util.extend({}, input);
        // we recognize copies by the occurrence property
        newInput.occurrence = (input.occurrence || 0) + 1;
        process.dataInputs.push(newInput);
        fn(newInput, field);
    }
}

// helper function for adding events to form fields
function addValueHandlers(field, onblur) {
    field.onclick = function() {
        if (!this.initialValue) {
            this.initialValue = this.value;
            this.value = "";
        }
    };
    field.onblur = function() {
        if (!this.value) {
            this.value = this.initialValue;
            delete this.initialValue;
        }
        onblur.apply(this, arguments);
    };
}

// execute the process
function execute() {
    var output = process.processOutputs[0];
    var input;
    // remove occurrences that the user has not filled out
    for (var i=process.dataInputs.length-1; i>=0; --i) {
        input = process.dataInputs[i];
        if ((input.minOccurs === 0 || input.occurrence) && !input.data && !input.reference) {
            OpenLayers.Util.removeItem(process.dataInputs, input);
        }
    }
    process.responseForm = {
        rawDataOutput: {
            identifier: output.identifier
        }
    };
    if (output.complexOutput && output.complexOutput.supported.formats["application/wkt"]) {
        process.responseForm.rawDataOutput.mimeType = "application/wkt";
    }
    OpenLayers.Request.POST({
        url: wps,
        data: new OpenLayers.Format.WPSExecute().write(process),
        success: showOutput
    });
}

// add the process's output to the page
function showOutput(response) {
    var result = document.getElementById("output");
    result.innerHTML = "<h3>Output:</h3>";
    var features;
    var contentType = response.getResponseHeader("Content-Type");
    if (contentType == "application/wkt") {
        features = new OpenLayers.Format.WKT().read(response.responseText);
    } else if (contentType == "text/xml; subtype=wfs-collection/1.0") {
        features = new OpenLayers.Format.WFST.v1_0_0().read(response.responseText);
    }
    if (features && (features instanceof OpenLayers.Feature.Vector || features.length)) {
        layer.addFeatures(features);
        result.innerHTML += "The result should also be visible on the map.";
    }
    result.innerHTML += "<textarea>" + response.responseText + "</textarea>";
}
    </script>
	<?php


	function get_location($ip) {
		$content = @file_get_contents('http://api.hostip.info/?ip='.$ip);
		if ($content != FALSE) {
echo'<pre style="max-height:200px;overflow:auto;border:1px solid red;text-align:left;">content (' . __CLASS__ . '::' . __FUNCTION__ . ':' . __LINE__ . '): ';print_r($content);echo'</pre>';
			$xml = new SimpleXmlElement($content);
echo'<pre style="max-height:200px;overflow:auto;border:1px solid red;text-align:left;">xml (' . __CLASS__ . '::' . __FUNCTION__ . ':' . __LINE__ . '): ';print_r($xml);echo'</pre>';
			$coordinates = $xml->children('gml', TRUE)->featureMember->children('', TRUE)->Hostip->ipLocation->children('gml', TRUE)->pointProperty->Point->coordinates;
			$longlat = explode(',', $coordinates);
			$location['longitude'] = $longlat[0];
			$location['latitude'] = $longlat[1];		
									$location['citystate'] = '==>'.$xml->children('gml', TRUE)->featureMember->children('', TRUE)->Hostip->children('gml', TRUE)->name;
			$location['country'] =  '==>'.$xml->children('gml', TRUE)->featureMember->children('', TRUE)->Hostip->countryName;
			return $location;
		}
		else return false;
	}

$ip = '94.158.130.34';// biuro.biall-net.pl
$location_info = get_location($ip);
echo'<pre style="max-height:200px;overflow:auto;border:1px solid red;text-align:left;">location_info('.$ip.') (' . __CLASS__ . '::' . __FUNCTION__ . ':' . __LINE__ . '): ';print_r($location_info);echo'</pre>';
/*
	$the_xml = file_get_contents('');
	$feed = new SimpleXMLElement($the_xml);
	$namespaces = $feed->getNamespaces(true);
	foreach ($feed->entry as $entry) {
		$event = $entry->children($namespaces['gd']);
		echo "<p>Event = " . $entry->title . "<br />startTime = " . $event->when->startTime . " and endTime = " . $event->when->endTime . "</p>\n";
	}
*/

}


class WpsServer {

	public function getCapabilitiesAction() {
		echo '<?xml version="1.0" encoding="UTF-8"?>';
		?>
<wps:Capabilities 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" xml:lang="en" service="WPS" version="1.0.0" xsi:schemaLocation="http://www.opengis.net/wps/1.0.0 http://schemas.opengis.net/wps/1.0.0/wpsAll.xsd">
    <ows:ServiceIdentification>
        <ows:Title>Prototype GeoServer WPS</ows:Title>
        <ows:Abstract />
        <ows:Keywords>
            <ows:Keyword>wps</ows:Keyword>
            <ows:Keyword>geoserver</ows:Keyword>
        </ows:Keywords>
        <ows:ServiceType>WPS</ows:ServiceType>
        <ows:ServiceTypeVersion>1.0.0</ows:ServiceTypeVersion>
        <ows:Fees>NONE</ows:Fees>
        <ows:AccessConstraints>NONE</ows:AccessConstraints>
    </ows:ServiceIdentification>
    <ows:ServiceProvider>
        <ows:ProviderName>GeoServer</ows:ProviderName>
        <ows:ProviderSite />
        <ows:ServiceContact />
    </ows:ServiceProvider>
    <ows:OperationsMetadata>
        <ows:Operation name="GetCapabilities">
            <ows:DCP>
                <ows:HTTP>
                    <ows:Get xlink:href="http://demo.opengeo.org:80/geoserver/wps" />
                    <ows:Post xlink:href="http://demo.opengeo.org:80/geoserver/wps" />
                </ows:HTTP>
            </ows:DCP>
        </ows:Operation>
        <ows:Operation name="DescribeProcess">
            <ows:DCP>
                <ows:HTTP>
                    <ows:Get xlink:href="http://demo.opengeo.org:80/geoserver/wps" />
                    <ows:Post xlink:href="http://demo.opengeo.org:80/geoserver/wps" />
                </ows:HTTP>
            </ows:DCP>
        </ows:Operation>
        <ows:Operation name="Execute">
            <ows:DCP>
                <ows:HTTP>
                    <ows:Get xlink:href="http://demo.opengeo.org:80/geoserver/wps" />
                    <ows:Post xlink:href="http://demo.opengeo.org:80/geoserver/wps" />
                </ows:HTTP>
            </ows:DCP>
        </ows:Operation>
    </ows:OperationsMetadata>
    <wps:ProcessOfferings>
        <wps:Process wps:processVersion="1.0.0">
            <ows:Identifier>pozdrawiam</ows:Identifier>
            <ows:Title>Area</ows:Title>
            <ows:Abstract>Returns the area of a geometry, in the units of the geometry. Assumes a Cartesian plane, so this process is only recommended for non-geographic CRSes.</ows:Abstract>
        </wps:Process>
    </wps:ProcessOfferings>
    <wps:Languages>
        <wps:Default>
            <ows:Language>en-US</ows:Language>
        </wps:Default>
        <wps:Supported>
            <ows:Language>en-US</ows:Language>
        </wps:Supported>
    </wps:Languages>
</wps:Capabilities>

		<?php
	}

	public function DescribeProcess($args) {
		// TODO: xml z opiesem procese $args['IDENTIFIER']
		/**
		 * should work like JTS:densify - geom field (map object) and integer field (record ID)
		 * http://openlayers.org/dev/examples/proxy.cgi?url=http%3A%2F%2Fdemo.opengeo.org%2Fgeoserver%2Fwps%3FSERVICE%3DWPS%26REQUEST%3DDescribeProcess%26VERSION%3D1.0.0%26IDENTIFIER%3DJTS%253Adensify
		 * http://demo.opengeo.org/geoserver/wps?SERVICE=WPS&REQUEST=DescribeProcess&VERSION=1.0.0&IDENTIFIER=JTS%3Adensify
		 */
		echo '<?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" xml:lang="en" service="WPS" version="1.0.0" xsi:schemaLocation="http://www.opengis.net/wps/1.0.0 http://schemas.opengis.net/wps/1.0.0/wpsAll.xsd">
  <ProcessDescription wps:processVersion="1.0.0" statusSupported="true" storeSupported="true">
    <ows:Identifier>JTS:densify</ows:Identifier>
    <ows:Title>Densify</ows:Title>
    <ows:Abstract>Returns a spatially equivalent geometry with vertices added to ensure line segments are no longer than a given distance.</ows:Abstract>
    <DataInputs>
      <Input maxOccurs="1" minOccurs="1">
        <ows:Identifier>geom</ows:Identifier>
        <ows:Title>geom</ows:Title>
        <ows:Abstract>Input geometry</ows:Abstract>
        <ComplexData>
          <Default>
            <Format>
              <MimeType>text/xml; subtype=gml/3.1.1</MimeType>
            </Format>
          </Default>
          <Supported>
            <Format>
              <MimeType>text/xml; subtype=gml/3.1.1</MimeType>
            </Format>
            <Format>
              <MimeType>text/xml; subtype=gml/2.1.2</MimeType>
            </Format>
            <Format>
              <MimeType>application/wkt</MimeType>
            </Format>
            <Format>
              <MimeType>application/gml-3.1.1</MimeType>
            </Format>
            <Format>
              <MimeType>application/gml-2.1.2</MimeType>
            </Format>
          </Supported>
        </ComplexData>
      </Input>
      <Input maxOccurs="1" minOccurs="1">
        <ows:Identifier>distance</ows:Identifier>
        <ows:Title>distance</ows:Title>
        <ows:Abstract>The maximum segment length in the result, in the units of the geometry</ows:Abstract>
        <LiteralData>
          <ows:DataType>xs:double</ows:DataType>
          <ows:AnyValue />
        </LiteralData>
      </Input>
    </DataInputs>
    <ProcessOutputs>
      <Output>
        <ows:Identifier>result</ows:Identifier>
        <ows:Title>result</ows:Title>
        <ComplexOutput>
          <Default>
            <Format>
              <MimeType>text/xml; subtype=gml/3.1.1</MimeType>
            </Format>
          </Default>
          <Supported>
            <Format>
              <MimeType>text/xml; subtype=gml/3.1.1</MimeType>
            </Format>
            <Format>
              <MimeType>text/xml; subtype=gml/2.1.2</MimeType>
            </Format>
            <Format>
              <MimeType>application/wkt</MimeType>
            </Format>
            <Format>
              <MimeType>application/gml-3.1.1</MimeType>
            </Format>
            <Format>
              <MimeType>application/gml-2.1.2</MimeType>
            </Format>
          </Supported>
        </ComplexOutput>
      </Output>
    </ProcessOutputs>
  </ProcessDescription>
</wps:ProcessDescriptions>
		<?php
	}
}