Index: modules/unsupported/process-feature/src/main/java/org/geotools/process/feature/gs/FeatureGSProcessFactory.java
===================================================================
--- modules/unsupported/process-feature/src/main/java/org/geotools/process/feature/gs/FeatureGSProcessFactory.java	(revision 38653)
+++ modules/unsupported/process-feature/src/main/java/org/geotools/process/feature/gs/FeatureGSProcessFactory.java	(working copy)
@@ -2,27 +2,7 @@
 
 import org.geotools.process.factory.AnnotatedBeanProcessFactory;
 import org.geotools.process.factory.DescribeProcess;
-import org.geotools.process.feature.gs.AggregateProcess;
-import org.geotools.process.feature.gs.BoundsProcess;
-import org.geotools.process.feature.gs.BufferFeatureCollection;
-import org.geotools.process.feature.gs.ClipProcess;
-import org.geotools.process.feature.gs.CollectGeometries;
-import org.geotools.process.feature.gs.CountProcess;
-import org.geotools.process.feature.gs.GridProcess;
-import org.geotools.process.feature.gs.InclusionFeatureCollection;
-import org.geotools.process.feature.gs.IntersectionFeatureCollection;
-import org.geotools.process.feature.gs.NearestProcess;
-import org.geotools.process.feature.gs.PointBuffers;
-import org.geotools.process.feature.gs.QueryProcess;
-import org.geotools.process.feature.gs.RectangularClipProcess;
-import org.geotools.process.feature.gs.ReprojectProcess;
-import org.geotools.process.feature.gs.SimplifyProcess;
-import org.geotools.process.feature.gs.SnapProcess;
-import org.geotools.process.feature.gs.UnionFeatureCollection;
-import org.geotools.process.feature.gs.UniqueProcess;
-import org.geotools.process.feature.gs.VectorZonalStatistics;
 import org.geotools.text.Text;
-import org.opengis.util.InternationalString;
 
 /**
  * Factory providing a number of processes for working with feature data.
@@ -37,29 +17,32 @@
  */
 public class FeatureGSProcessFactory extends AnnotatedBeanProcessFactory {
 
-    public FeatureGSProcessFactory() {
-        super(Text.text("Geospatial Feature Process Factory"), "gs",
-                AggregateProcess.class,
-                BoundsProcess.class,
-                BufferFeatureCollection.class,
-                ClipProcess.class,
-                CollectGeometries.class,
-                CountProcess.class,
-                FeatureProcess.class,
-                GridProcess.class,
-                InclusionFeatureCollection.class,
-                IntersectionFeatureCollection.class,
-                NearestProcess.class,
-                PointBuffers.class,
-                QueryProcess.class,
-                RectangularClipProcess.class,
-                ReprojectProcess.class,
-                SimplifyProcess.class,
-                SnapProcess.class,
-                UnionFeatureCollection.class,
-                UniqueProcess.class,
-                VectorZonalStatistics.class,
-                TransformProcess.class);
-    }
+	public FeatureGSProcessFactory() {
+		super(Text.text("Geospatial Feature Process Factory"), "gs",
+				AggregateProcess.class,
+				BoundsProcess.class,
+				BufferFeatureCollection.class,
+				ClipProcess.class,
+				CollectGeometries.class,
+				CountProcess.class,
+				FeatureProcess.class,
+				GridProcess.class,
+				InclusionFeatureCollection.class,
+				IntersectionFeatureCollection.class,
+				NearestProcess.class,
+				PointBuffers.class,
+				QueryProcess.class,
+				RectangularClipProcess.class,
+				ReprojectProcess.class,
+				SimplifyProcess.class,
+				SnapProcess.class,
+				UnionFeatureCollection.class,
+				UniqueProcess.class,
+				VectorZonalStatistics.class,
+				TransformProcess.class,
+				LRSGeocodeProcess.class,
+				LRSMeasureProcess.class,
+				LRSSegmentProcess.class);
+	}
 
 }
Index: modules/unsupported/process-feature/src/main/java/org/geotools/process/feature/gs/LRSGeocodeProcess.java
===================================================================
--- modules/unsupported/process-feature/src/main/java/org/geotools/process/feature/gs/LRSGeocodeProcess.java	(revision 0)
+++ modules/unsupported/process-feature/src/main/java/org/geotools/process/feature/gs/LRSGeocodeProcess.java	(working copy)
@@ -0,0 +1,156 @@
+/*
+ *    GeoTools - The Open Source Java GIS Toolkit
+ *    http://geotools.org
+ *
+ *    (C) 2011, Open Source Geospatial Foundation (OSGeo)
+ *    (C) 2001-2007 TOPP - www.openplans.org.
+ *
+ *    This library is free software; you can redistribute it and/or
+ *    modify it under the terms of the GNU Lesser General Public
+ *    License as published by the Free Software Foundation;
+ *    version 2.1 of the License.
+ *
+ *    This library is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *    Lesser General Public License for more details.
+ */
+package org.geotools.process.feature.gs;
+
+import java.util.Iterator;
+import java.util.logging.Logger;
+
+import org.geotools.feature.FeatureCollection;
+import org.geotools.feature.FeatureCollections;
+import org.geotools.feature.simple.SimpleFeatureBuilder;
+import org.geotools.process.ProcessException;
+import org.geotools.process.factory.DescribeParameter;
+import org.geotools.process.factory.DescribeProcess;
+import org.geotools.process.factory.DescribeResult;
+import org.geotools.process.gs.GSProcess;
+import org.geotools.util.logging.Logging;
+import org.opengis.feature.Feature;
+import org.opengis.feature.simple.SimpleFeature;
+import org.opengis.feature.simple.SimpleFeatureType;
+import org.opengis.feature.type.AttributeDescriptor;
+
+import com.vividsolutions.jts.geom.Coordinate;
+import com.vividsolutions.jts.geom.Geometry;
+import com.vividsolutions.jts.geom.GeometryFactory;
+import com.vividsolutions.jts.linearref.LengthIndexedLine;
+
+@DescribeProcess(title = "LRSGeocode", description = "Translate LRS measure to geocoded point")
+/**
+ * 
+ *
+ * @source $URL: http://svn.osgeo.org/geotools/trunk/modules/unsupported/process-feature/src/main/java/org/geotools/process/feature/gs/NearestProcess.java $
+ */
+public class LRSGeocodeProcess implements GSProcess {
+	private static final Logger LOGGER = Logging.getLogger(LRSGeocodeProcess.class);
+
+	private final GeometryFactory geometryFactory = new GeometryFactory();
+
+	/**
+	 * Process the input data set.
+	 * 
+	 * @param featureCollection
+	 *            the data set
+	 * @param crs
+	 *            the CRS
+	 * @param point
+	 *            the given point
+	 * @return the snapped to feature
+	 * @throws ProcessException
+	 *             error
+	 */
+	@DescribeResult(name = "result", description = "The geocoded point")
+	public FeatureCollection execute(
+			@DescribeParameter(name = "features", description = "The features to search") FeatureCollection featureCollection,
+			@DescribeParameter(name = "from_measure_attb", description = "The feature attribue holding the features starting measure") String fromMeasureAttb,
+			@DescribeParameter(name = "to_measure_attb", description = "The feature attribue holding the features ending measure") String toMeasureAttb,
+			@DescribeParameter(name = "measure", description = "The LRS measure") Double measure)
+					throws ProcessException {
+		try {
+			if (fromMeasureAttb == null) {
+				throw new ProcessException(
+						"The from_measure_attb parameter was not provided");
+			}
+			if (toMeasureAttb == null) {
+				throw new ProcessException(
+						"The to_measure_attb parameter was not provided");
+			}
+			if (measure == null) {
+				throw new ProcessException(
+						"The measure parameter was not provided");
+			}
+			if (featureCollection == null || featureCollection.size() == 0) {
+				throw new ProcessException(
+						"No features were provided");
+			}
+
+			FeatureCollection results = FeatureCollections.newCollection();
+			Iterator featureIterator = null;
+			try {
+				featureIterator = featureCollection.iterator();
+				Feature feature = (Feature)featureIterator.next();
+				Double featureFromMeasure = (Double)feature.getProperty(fromMeasureAttb).getValue();
+				Double featureToMeasure = (Double)feature.getProperty(toMeasureAttb).getValue();
+				LengthIndexedLine lengthIndexedLine = new LengthIndexedLine((Geometry)feature.getDefaultGeometryProperty().getValue());
+				double featureLength = featureToMeasure - featureFromMeasure;
+				double startOffset = measure - featureFromMeasure;
+				double calcLength = ((Geometry)feature.getDefaultGeometryProperty().getValue()).getLength();
+				if (calcLength == 0) throw new ProcessException("Edge feature has zero length");
+				if (featureLength == 0) throw new ProcessException("Requested feature has zero length");
+				Coordinate point = lengthIndexedLine.extractPoint(startOffset * calcLength / featureLength);
+				results.add(createTargetFeature(feature,
+						(SimpleFeatureType)feature.getType(), point));
+			} finally {
+				if (featureIterator != null)
+					featureCollection.close(featureIterator);
+			}
+			return results;
+		} catch (ProcessException e) {
+			throw e;
+		} catch (Throwable e) {
+			LOGGER.warning("Error executing method: " + e);
+			throw new ProcessException("Error executing method: " + e, e);
+		}
+	}
+
+	/**
+	 * Create the modified feature.
+	 * 
+	 * @param feature
+	 *            the source feature
+	 * @param targetFeatureType
+	 *            the modified feature type
+	 * @param nearestDistance
+	 *            the snap distance
+	 * @param nearestBearing
+	 *            the snap bearing
+	 * @return the modified feature
+	 * @throws ProcessException
+	 *             error
+	 */
+	private SimpleFeature createTargetFeature(Feature feature, SimpleFeatureType targetFeatureType,
+			Coordinate geocodePoint)
+					throws ProcessException {
+		try {
+			AttributeDescriptor geomAttbType = targetFeatureType.getGeometryDescriptor();
+			Object[] attributes = new Object[targetFeatureType.getAttributeCount()];
+			for (int i = 0; i < attributes.length; i++) {
+				AttributeDescriptor attbType = targetFeatureType.getAttributeDescriptors().get(i);
+				if (attbType.equals(geomAttbType)) {
+					attributes[i] = geometryFactory.createPoint(geocodePoint);
+				} else {
+					attributes[i] = feature.getProperty(attbType.getName()).getValue();
+				}
+			}
+			return SimpleFeatureBuilder.build(targetFeatureType, attributes, feature
+					.getIdentifier().getID());
+		} catch (Exception e) {
+			LOGGER.warning("Error creating feature: " + e);
+			throw new ProcessException("Error creating feature: " + e, e);
+		}
+	}
+}
Index: modules/unsupported/process-feature/src/main/java/org/geotools/process/feature/gs/LRSMeasureProcess.java
===================================================================
--- modules/unsupported/process-feature/src/main/java/org/geotools/process/feature/gs/LRSMeasureProcess.java	(revision 0)
+++ modules/unsupported/process-feature/src/main/java/org/geotools/process/feature/gs/LRSMeasureProcess.java	(working copy)
@@ -0,0 +1,263 @@
+/*
+ *    GeoTools - The Open Source Java GIS Toolkit
+ *    http://geotools.org
+ *
+ *    (C) 2011, Open Source Geospatial Foundation (OSGeo)
+ *    (C) 2001-2007 TOPP - www.openplans.org.
+ *
+ *    This library is free software; you can redistribute it and/or
+ *    modify it under the terms of the GNU Lesser General Public
+ *    License as published by the Free Software Foundation;
+ *    version 2.1 of the License.
+ *
+ *    This library is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *    Lesser General Public License for more details.
+ */
+package org.geotools.process.feature.gs;
+
+import java.util.Iterator;
+import java.util.logging.Logger;
+
+import javax.measure.converter.UnitConverter;
+import javax.measure.unit.SI;
+import javax.measure.unit.Unit;
+
+import org.geotools.feature.FeatureCollection;
+import org.geotools.feature.FeatureCollections;
+import org.geotools.feature.simple.SimpleFeatureBuilder;
+import org.geotools.feature.simple.SimpleFeatureTypeBuilder;
+import org.geotools.measure.Measure;
+import org.geotools.process.ProcessException;
+import org.geotools.process.factory.DescribeParameter;
+import org.geotools.process.factory.DescribeProcess;
+import org.geotools.process.factory.DescribeResult;
+import org.geotools.process.gs.GSProcess;
+import org.geotools.referencing.CRS;
+import org.geotools.referencing.crs.DefaultGeographicCRS;
+import org.geotools.util.logging.Logging;
+import org.opengis.feature.Feature;
+import org.opengis.feature.simple.SimpleFeature;
+import org.opengis.feature.simple.SimpleFeatureType;
+import org.opengis.feature.type.AttributeDescriptor;
+import org.opengis.feature.type.FeatureType;
+import org.opengis.feature.type.GeometryDescriptor;
+import org.opengis.feature.type.PropertyDescriptor;
+import org.opengis.referencing.crs.CoordinateReferenceSystem;
+import org.opengis.referencing.operation.MathTransform;
+
+import com.vividsolutions.jts.geom.Coordinate;
+import com.vividsolutions.jts.geom.Geometry;
+import com.vividsolutions.jts.geom.GeometryFactory;
+import com.vividsolutions.jts.geom.Point;
+import com.vividsolutions.jts.linearref.LengthIndexedLine;
+import com.vividsolutions.jts.operation.distance.DistanceOp;
+
+@DescribeProcess(title = "LRSGeocode", description = "Translate geocoded point to LRS measure")
+/**
+ * 
+ *
+ * @source $URL: http://svn.osgeo.org/geotools/trunk/modules/unsupported/process-feature/src/main/java/org/geotools/process/feature/gs/NearestProcess.java $
+ */
+public class LRSMeasureProcess implements GSProcess {
+	private static final Logger LOGGER = Logging.getLogger(LRSMeasureProcess.class);
+
+	private final GeometryFactory geometryFactory = new GeometryFactory();
+
+	/**
+	 * Process the input data set.
+	 * 
+	 * @param featureCollection
+	 *            the data set
+	 * @param crs
+	 *            the CRS
+	 * @param point
+	 *            the given point
+	 * @return the snapped to feature
+	 * @throws ProcessException
+	 *             error
+	 */
+	@DescribeResult(name = "result", description = "The LRS measure")
+	public FeatureCollection execute(
+			@DescribeParameter(name = "features", description = "The features to search") FeatureCollection featureCollection,
+			@DescribeParameter(name = "from_measure_attb", description = "The feature attribue holding the features starting measure") String fromMeasureAttb,
+			@DescribeParameter(name = "to_measure_attb", description = "The feature attribue holding the features ending measure") String toMeasureAttb,
+			@DescribeParameter(name = "point", description = "The point to search from") Point point,
+			@DescribeParameter(name = "crs", min = 0, description = "The coordinate reference system of the collection and point (will use the collection one if not provided") CoordinateReferenceSystem crs)
+					throws ProcessException {
+		try {
+			if (crs == null) {
+				GeometryDescriptor gd = featureCollection.getSchema().getGeometryDescriptor();
+				if (gd != null) {
+					crs = gd.getCoordinateReferenceSystem();
+				}
+			}
+			if (crs == null) {
+				throw new ProcessException(
+						"The CRS parameter was not provided and the feature collection does not have a default one either");
+			}
+			if (fromMeasureAttb == null) {
+				throw new ProcessException(
+						"The from_measure_attb parameter was not provided");
+			}
+			if (toMeasureAttb == null) {
+				throw new ProcessException(
+						"The to_measure_attb parameter was not provided");
+			}
+			if (point == null) {
+				throw new ProcessException(
+						"The point parameter was not provided");
+			}
+			if (featureCollection == null || featureCollection.size() == 0) {
+				throw new ProcessException(
+						"No features were provided");
+			}
+
+			CoordinateReferenceSystem epsg4326;
+			try {
+				epsg4326 = CRS.decode("EPSG:4326");
+			} catch (Exception e) {
+				throw new ProcessException("Unknown CRS code: EPSG:4326", e);
+			}
+			MathTransform crsTransform = CRS.findMathTransform(crs, epsg4326);
+
+			FeatureCollection results = FeatureCollections.newCollection();
+			FeatureType targetFeatureType = createTargetFeatureType(featureCollection.getSchema());
+			Unit fromUnit = SI.METER;
+			Unit toUnit = Unit.valueOf("mi");
+			UnitConverter unitConvert = fromUnit.getConverterTo(toUnit);
+			Feature nearestFeature = null;
+			double nearestDistance = 9e9;
+			Coordinate[] nearestCoords = null;
+			Iterator featureIterator = null;
+			try {
+				featureIterator = featureCollection.iterator();
+				while (featureIterator.hasNext()) {
+					SimpleFeature f = (SimpleFeature) featureIterator.next();
+					if (f.getDefaultGeometryProperty().getValue() == null)
+						continue;
+					DistanceOp op = new DistanceOp(point, (Geometry) f.getDefaultGeometryProperty()
+							.getValue());
+					Coordinate[] co = op.closestPoints();
+					double[] co0 = new double[] { co[0].x, co[0].y, };
+					double[] co1 = new double[] { co[1].x, co[1].y, };
+					double[] geo0 = new double[2];
+					double[] geo1 = new double[2];
+					crsTransform.transform(co0, 0, geo0, 0, 1);
+					crsTransform.transform(co1, 0, geo1, 0, 1);
+
+					// get distance
+					Measure m = DefaultGeographicCRS.WGS84.distance(geo0, geo1);
+					if (m.doubleValue() > nearestDistance)
+						continue;
+					nearestFeature = f;
+					nearestDistance = m.doubleValue();
+					nearestCoords = co;
+				}
+			} finally {
+				if (featureIterator != null)
+					featureCollection.close(featureIterator);
+			}
+			if (nearestFeature != null) {
+				LengthIndexedLine lengthIndexedLine = new LengthIndexedLine((Geometry)nearestFeature.getDefaultGeometryProperty().getValue());
+				double lineIndex = lengthIndexedLine.indexOf(nearestCoords[1]);
+				double lineLength = ((Geometry)nearestFeature.getDefaultGeometryProperty().getValue()).getLength();
+				Double featureFromMeasure = (Double)nearestFeature.getProperty(fromMeasureAttb).getValue();
+				Double featureToMeasure = (Double)nearestFeature.getProperty(toMeasureAttb).getValue();
+				double lrsMeasure = featureFromMeasure + (featureToMeasure - featureFromMeasure) * lineIndex / lineLength;
+				nearestFeature.getDefaultGeometryProperty().setValue(geometryFactory.createPoint(new Coordinate(nearestCoords[1].x, nearestCoords[1].y)));
+				results.add(createTargetFeature(nearestFeature, (SimpleFeatureType) targetFeatureType, lrsMeasure));
+				return results;
+			}
+			return results;
+		} catch (ProcessException e) {
+			throw e;
+		} catch (Throwable e) {
+			LOGGER.warning("Error executing method: " + e);
+			throw new ProcessException("Error executing method: " + e, e);
+		}
+	}
+
+	/**
+	 * Create the modified feature type.
+	 * 
+	 * @param sourceFeatureType
+	 *            the source feature type
+	 * @return the modified feature type
+	 * @throws ProcessException
+	 *             errror
+	 */
+	private SimpleFeatureType createTargetFeatureType(FeatureType sourceFeatureType)
+			throws ProcessException {
+		try {
+			SimpleFeatureTypeBuilder typeBuilder = new SimpleFeatureTypeBuilder();
+			typeBuilder.setName(sourceFeatureType.getName().getLocalPart());
+			typeBuilder.setNamespaceURI(sourceFeatureType.getName().getNamespaceURI());
+			for (PropertyDescriptor attbType : sourceFeatureType.getDescriptors()) {
+				typeBuilder.add((AttributeDescriptor) attbType);
+			}
+			typeBuilder.minOccurs(1).maxOccurs(1).nillable(false).add("lrs_measure",
+					Double.class);
+			typeBuilder
+			.setDefaultGeometry(sourceFeatureType.getGeometryDescriptor().getLocalName());
+			return typeBuilder.buildFeatureType();
+		} catch (Exception e) {
+			LOGGER.warning("Error creating type: " + e);
+			throw new ProcessException("Error creating type: " + e, e);
+		}
+	}
+
+	/**
+	 * Create the modified feature.
+	 * 
+	 * @param feature
+	 *            the source feature
+	 * @param targetFeatureType
+	 *            the modified feature type
+	 * @param nearestDistance
+	 *            the snap distance
+	 * @param nearestBearing
+	 *            the snap bearing
+	 * @return the modified feature
+	 * @throws ProcessException
+	 *             error
+	 */
+	private SimpleFeature createTargetFeature(Feature feature, SimpleFeatureType targetFeatureType,
+			Double lrsMeasure) throws ProcessException {
+		try {
+			AttributeDescriptor lrsMeasureAttbType = targetFeatureType
+					.getDescriptor("lrs_measure");
+			Object[] attributes = new Object[targetFeatureType.getAttributeCount()];
+			for (int i = 0; i < attributes.length; i++) {
+				AttributeDescriptor attbType = targetFeatureType.getAttributeDescriptors().get(i);
+				if (attbType.equals(lrsMeasureAttbType)) {
+					attributes[i] = lrsMeasure;
+				} else {
+					attributes[i] = feature.getProperty(attbType.getName()).getValue();
+				}
+			}
+			return SimpleFeatureBuilder.build(targetFeatureType, attributes, feature
+					.getIdentifier().getID());
+		} catch (Exception e) {
+			LOGGER.warning("Error creating feature: " + e);
+			throw new ProcessException("Error creating feature: " + e, e);
+		}
+	}
+
+	/**
+	 * Calculate the bearing between two points.
+	 * 
+	 * @param coords
+	 *            the points
+	 * @return the bearing
+	 */
+	private double calcBearing(Coordinate[] coords) {
+		double y = Math.sin(coords[1].x - coords[0].x) * Math.cos(coords[1].y);
+		double x = Math.cos(coords[0].y) * Math.sin(coords[1].y) - Math.sin(coords[0].y)
+				* Math.cos(coords[1].y) * Math.cos(coords[1].x - coords[0].x);
+		double brng = ((Math.atan2(y, x) * 180.0 / Math.PI) + 360) % 360;
+		return brng;
+	}
+
+}
Index: modules/unsupported/process-feature/src/main/java/org/geotools/process/feature/gs/LRSSegmentProcess.java
===================================================================
--- modules/unsupported/process-feature/src/main/java/org/geotools/process/feature/gs/LRSSegmentProcess.java	(revision 0)
+++ modules/unsupported/process-feature/src/main/java/org/geotools/process/feature/gs/LRSSegmentProcess.java	(working copy)
@@ -0,0 +1,204 @@
+/*
+ *    GeoTools - The Open Source Java GIS Toolkit
+ *    http://geotools.org
+ *
+ *    (C) 2011, Open Source Geospatial Foundation (OSGeo)
+ *    (C) 2001-2007 TOPP - www.openplans.org.
+ *
+ *    This library is free software; you can redistribute it and/or
+ *    modify it under the terms of the GNU Lesser General Public
+ *    License as published by the Free Software Foundation;
+ *    version 2.1 of the License.
+ *
+ *    This library is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ *    Lesser General Public License for more details.
+ */
+package org.geotools.process.feature.gs;
+
+import java.util.Iterator;
+import java.util.logging.Logger;
+
+import org.geotools.feature.FeatureCollection;
+import org.geotools.feature.FeatureCollections;
+import org.geotools.feature.simple.SimpleFeatureBuilder;
+import org.geotools.process.ProcessException;
+import org.geotools.process.factory.DescribeParameter;
+import org.geotools.process.factory.DescribeProcess;
+import org.geotools.process.factory.DescribeResult;
+import org.geotools.process.gs.GSProcess;
+import org.geotools.util.logging.Logging;
+import org.opengis.feature.Feature;
+import org.opengis.feature.simple.SimpleFeature;
+import org.opengis.feature.simple.SimpleFeatureType;
+import org.opengis.feature.type.AttributeDescriptor;
+
+import com.vividsolutions.jts.geom.Geometry;
+import com.vividsolutions.jts.geom.GeometryFactory;
+import com.vividsolutions.jts.geom.LineString;
+import com.vividsolutions.jts.geom.MultiLineString;
+import com.vividsolutions.jts.linearref.LengthIndexedLine;
+import com.vividsolutions.jts.operation.linemerge.LineMerger;
+
+@DescribeProcess(title = "LRSSegment", description = "Return a segment geometry for a LRM measure range")
+/**
+ * 
+ *
+ * @source $URL: http://svn.osgeo.org/geotools/trunk/modules/unsupported/process-feature/src/main/java/org/geotools/process/feature/gs/NearestProcess.java $
+ */
+public class LRSSegmentProcess implements GSProcess {
+	private static final Logger LOGGER = Logging.getLogger(LRSSegmentProcess.class);
+
+	private final GeometryFactory geometryFactory = new GeometryFactory();
+
+	/**
+	 * Process the input data set.
+	 * 
+	 * @param featureCollection
+	 *            the data set
+	 * @param crs
+	 *            the CRS
+	 * @param point
+	 *            the given point
+	 * @return the snapped to feature
+	 * @throws ProcessException
+	 *             error
+	 */
+	@DescribeResult(name = "result", description = "The segment geometry")
+	public FeatureCollection execute(
+			@DescribeParameter(name = "features", description = "The features to search") FeatureCollection featureCollection,
+			@DescribeParameter(name = "from_measure_attb", description = "The feature attribue holding the features starting measure") String fromMeasureAttb,
+			@DescribeParameter(name = "to_measure_attb", description = "The feature attribue holding the features ending measure") String toMeasureAttb,
+			@DescribeParameter(name = "from_measure", description = "The from LRS measure") Double fromMeasure,
+			@DescribeParameter(name = "to_measure", description = "The to LRS measure") Double toMeasure)
+					throws ProcessException {
+		try {
+			if (fromMeasureAttb == null) {
+				throw new ProcessException(
+						"The from_measure_attb parameter was not provided");
+			}
+			if (toMeasureAttb == null) {
+				throw new ProcessException(
+						"The to_measure_attb parameter was not provided");
+			}
+			if (fromMeasure == null) {
+				throw new ProcessException(
+						"The from_measure parameter was not provided");
+			}
+			if (toMeasure == null) {
+				throw new ProcessException(
+						"The to_measure parameter was not provided");
+			}
+			if (fromMeasure.doubleValue() == toMeasure.doubleValue()) {
+				throw new ProcessException(
+						"The specified zegment is of zero length");
+			}
+			if (featureCollection == null || featureCollection.size() == 0) {
+				throw new ProcessException(
+						"No features were provided");
+			}
+
+			FeatureCollection results = FeatureCollections.newCollection();
+			Iterator featureIterator = null;
+			Feature firstFeature = null;
+			try {
+				LineMerger lineMerger = new LineMerger();
+				if (toMeasure.doubleValue() > fromMeasure.doubleValue()) {
+					featureIterator = featureCollection.iterator();
+					while (featureIterator.hasNext()) {
+						Feature feature = (Feature) featureIterator.next();
+						if (firstFeature == null) firstFeature = feature;
+						Double featureFromMeasure = (Double)feature.getProperty(fromMeasureAttb).getValue();
+						Double featureToMeasure = (Double)feature.getProperty(toMeasureAttb).getValue();
+
+						if (fromMeasure < featureToMeasure && toMeasure > featureFromMeasure) {
+							try {
+								if (fromMeasure <= featureFromMeasure && toMeasure >= featureToMeasure) {
+									lineMerger.add((Geometry)feature.getDefaultGeometryProperty().getValue());
+								} else if (fromMeasure > featureFromMeasure && toMeasure < featureToMeasure) {
+									LengthIndexedLine lengthIndexedLine = new LengthIndexedLine((Geometry)feature.getDefaultGeometryProperty().getValue());
+									double featureLength = featureToMeasure - featureFromMeasure;
+									double startOffset = fromMeasure - featureFromMeasure;
+									double stopOffset = toMeasure - featureFromMeasure;
+									double calcLength = ((Geometry)feature.getDefaultGeometryProperty().getValue()).getLength();
+									if (calcLength == 0 || featureLength == 0) continue;
+									Geometry extracted = lengthIndexedLine.extractLine(startOffset * calcLength / featureLength, stopOffset * calcLength / featureLength);
+									if (!extracted.isEmpty()) lineMerger.add(extracted);
+								} else if (fromMeasure > featureFromMeasure) {
+									LengthIndexedLine lengthIndexedLine = new LengthIndexedLine((Geometry)feature.getDefaultGeometryProperty().getValue());
+									double featureLength = featureToMeasure - featureFromMeasure;
+									double startOffset = fromMeasure - featureFromMeasure;
+									double calcLength = ((Geometry)feature.getDefaultGeometryProperty().getValue()).getLength();
+									if (calcLength == 0 || featureLength == 0) continue;
+									Geometry extracted = lengthIndexedLine.extractLine(startOffset * calcLength / featureLength, calcLength);
+									if (!extracted.isEmpty()) lineMerger.add(extracted);
+								} else {
+									LengthIndexedLine lengthIndexedLine = new LengthIndexedLine((Geometry)feature.getDefaultGeometryProperty().getValue());
+									double featureLength = featureToMeasure - featureFromMeasure;
+									double stopOffset = toMeasure - featureFromMeasure;
+									double calcLength = ((Geometry)feature.getDefaultGeometryProperty().getValue()).getLength();
+									if (calcLength == 0 || featureLength == 0) continue;
+									Geometry extracted = lengthIndexedLine.extractLine(0, stopOffset * calcLength / featureLength);
+									if (extracted.isEmpty() || extracted.getLength() == 0.0) {
+										LOGGER.info("Empty segment: featureFromMeasure=" + featureFromMeasure + " featureToMeasure:" + featureToMeasure + " toMeasure:" + toMeasure + " fromMeasure:" + fromMeasure);
+									} else {
+										lineMerger.add(extracted);
+									}
+								}
+							} catch (Exception e) {
+								LOGGER.warning("Error merging line strings: " + e + " featureFromMeasure=" + featureFromMeasure + " featureToMeasure:" + featureToMeasure + " toMeasure:" + toMeasure + " fromMeasure:" + fromMeasure);
+							}
+						}
+					}
+					results.add(createTargetFeature(firstFeature, (SimpleFeatureType)firstFeature.getType(), new MultiLineString((LineString[])lineMerger.getMergedLineStrings().toArray(new LineString[0]), geometryFactory)));				}
+			} finally {
+				if (featureIterator != null)
+					featureCollection.close(featureIterator);
+			}
+			return results;
+		} catch (ProcessException e) {
+			throw e;
+		} catch (Throwable e) {
+			LOGGER.warning("Error executing method: " + e);
+			throw new ProcessException("Error executing method: " + e, e);
+		}
+	}
+
+	/**
+	 * Create the modified feature.
+	 * 
+	 * @param feature
+	 *            the source feature
+	 * @param targetFeatureType
+	 *            the modified feature type
+	 * @param nearestDistance
+	 *            the snap distance
+	 * @param nearestBearing
+	 *            the snap bearing
+	 * @return the modified feature
+	 * @throws ProcessException
+	 *             error
+	 */
+	private SimpleFeature createTargetFeature(Feature feature, SimpleFeatureType targetFeatureType,
+			MultiLineString multiLineString)
+					throws ProcessException {
+		try {
+			AttributeDescriptor geomAttbType = targetFeatureType.getGeometryDescriptor();
+			Object[] attributes = new Object[targetFeatureType.getAttributeCount()];
+			for (int i = 0; i < attributes.length; i++) {
+				AttributeDescriptor attbType = targetFeatureType.getAttributeDescriptors().get(i);
+				if (attbType.equals(geomAttbType)) {
+					attributes[i] = multiLineString;
+				} else {
+					attributes[i] = feature.getProperty(attbType.getName()).getValue();
+				}
+			}
+			return SimpleFeatureBuilder.build(targetFeatureType, attributes, feature
+					.getIdentifier().getID());
+		} catch (Exception e) {
+			LOGGER.warning("Error creating feature: " + e);
+			throw new ProcessException("Error creating feature: " + e, e);
+		}
+	}
+}