Application: gvSIG desktop

/**

 * gvSIG. Desktop Geographic Information System.

 *

 * Copyright (C) 2007-2013 gvSIG Association.

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License

 * as published by the Free Software Foundation; either version 3

 * of the License, or (at your option) any later version.

 *

 * This program 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 General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,

 * MA  02110-1301, USA.

 *

 * For any additional information, do not hesitate to contact us

 * at info AT gvsig.com, or visit our website www.gvsig.com.

 */

package org.gvsig.fmap.geom.operation.fromjts;

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.GeometryLocator;

import org.gvsig.fmap.geom.GeometryManager;

import org.gvsig.fmap.geom.exception.CreateGeometryException;

import org.gvsig.fmap.geom.operation.GeometryOperation;

import org.gvsig.fmap.geom.operation.GeometryOperationContext;

import org.gvsig.fmap.geom.operation.GeometryOperationException;

import org.gvsig.fmap.geom.util.Converter;

/**

 * <p>

 * Converts a geometry from JTS to DAL format. This is a special geometry operation

 * because don't use the Geometry parameter and returns a JTS geometry. This kind

 * of operation can be called from the {@link GeometryManager} using invokeOperation.

 * </p>

 * <p>

 * This operation needs a JTS geometry loaded in the context. The only attribute

 * of the {@link GeometryOperation} have to be a geometry of this type and the ID 

 * of this attribute will be JTSGeometry.

 * </p>

 * 

 * @author Nacho Brodin (nachobrodin@gmail.com)

 *

 */

public class FromJTS extends GeometryOperation {

    public static final String NAME  = "fromJTS";

    public static final String PARAM = "JTSGeometry";

	protected static GeometryManager geomManager = GeometryLocator.getGeometryManager();

    public static final int CODE = geomManager.getGeometryOperationCode(NAME);	

	protected final static com.vividsolutions.jts.geom.GeometryFactory geomFactory = new com.vividsolutions.jts.geom.GeometryFactory();

	public int getOperationIndex() {

		return CODE;

	}

	/*

	 * (non-Javadoc)

	 * @see org.gvsig.fmap.geom.operation.GeometryOperation#invoke(org.gvsig.fmap.geom.Geometry, org.gvsig.fmap.geom.operation.GeometryOperationContext)

	 */

	public Object invoke(Geometry geom, GeometryOperationContext ctx)

			throws GeometryOperationException {

		Object obj = ctx.getAttribute("JTSGeometry");

		if(obj instanceof com.vividsolutions.jts.geom.Geometry) {

			try {

				return Converter.jtsToGeometry((com.vividsolutions.jts.geom.Geometry)obj);

			} catch (CreateGeometryException e) {

				throw new GeometryOperationException(e); 

			}

		}

		return null;

	}

}

/**

 * gvSIG. Desktop Geographic Information System.

 *

 * Copyright (C) 2007-2013 gvSIG Association.

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License

 * as published by the Free Software Foundation; either version 3

 * of the License, or (at your option) any later version.

 *

 * This program 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 General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,

 * MA  02110-1301, USA.

 *

 * For any additional information, do not hesitate to contact us

 * at info AT gvsig.com, or visit our website www.gvsig.com.

 */

package org.gvsig.fmap.geom.operation.towkb;

import java.util.HashMap;

import java.util.Map;

import org.gvsig.tools.exception.BaseException;

public abstract class WKBEncodingException extends BaseException {

	/**

	 *

	 */

	private static final long serialVersionUID = -7340057779411755446L;

	protected Map values = new HashMap();

	public WKBEncodingException(String messageFormat, Throwable cause,

			String messageKey, long code) {

		super(messageFormat, cause, messageKey, code);

	}

	public WKBEncodingException(String messageFormat, String messageKey, long code) {

		super(messageFormat, messageKey, code);

	}

	protected void setValue(String name, String value) {

		this.values.put(name, value);

	}

	protected Map values() {

		return this.values;

	}

}

/**

 * gvSIG. Desktop Geographic Information System.

 *

 * Copyright (C) 2007-2013 gvSIG Association.

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License

 * as published by the Free Software Foundation; either version 3

 * of the License, or (at your option) any later version.

 *

 * This program 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 General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,

 * MA  02110-1301, USA.

 *

 * For any additional information, do not hesitate to contact us

 * at info AT gvsig.com, or visit our website www.gvsig.com.

 */

package org.gvsig.fmap.geom.operation.towkb;

import org.gvsig.fmap.geom.operation.GeometryOperationContext;

/**

 * @author jmvivo

 *

 */

public class ToWKBOperationContext extends GeometryOperationContext {

	public static final String SRS = "srs";

	/**

	 * Set the srID to use in the WKB geometry

	 * 

	 * @param srID

	 */

	public void setSrID(int srID) {

		this.setAttribute(SRS, new Integer(srID));

	}

	/**

	 * Get the srId to use in the WKB geometry

	 * 

	 * @return

	 */

	public int getSrID() {

		Integer srs = (Integer) this.getAttribute(SRS);

		if( srs == null ) {

			return -1;

		}

		return srs.intValue();

	}

}

/**

 * gvSIG. Desktop Geographic Information System.

 *

 * Copyright (C) 2007-2013 gvSIG Association.

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License

 * as published by the Free Software Foundation; either version 3

 * of the License, or (at your option) any later version.

 *

 * This program 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 General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,

 * MA  02110-1301, USA.

 *

 * For any additional information, do not hesitate to contact us

 * at info AT gvsig.com, or visit our website www.gvsig.com.

 */

package org.gvsig.fmap.geom.operation.towkb;

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.GeometryLocator;

import org.gvsig.fmap.geom.operation.GeometryOperation;

import org.gvsig.fmap.geom.operation.GeometryOperationContext;

import org.gvsig.fmap.geom.operation.GeometryOperationException;

public class ToWKBNative extends GeometryOperation {

    public static final String NAME = "toWKBNative";

	public static final int CODE = GeometryLocator.getGeometryManager().

    	getGeometryOperationCode(NAME);

	private static WKBEncoder encoder = new WKBEncoder();

	public Object invoke(Geometry geom, GeometryOperationContext ctx)

			throws GeometryOperationException {

		try {

			return encoder.encode(geom);

		} catch (Exception e) {

			throw new GeometryOperationException(e);

		}

	}

	public int getOperationIndex() {

		return CODE;

	}

}

/**

 * gvSIG. Desktop Geographic Information System.

 *

 * Copyright (C) 2007-2013 gvSIG Association.

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License

 * as published by the Free Software Foundation; either version 3

 * of the License, or (at your option) any later version.

 *

 * This program 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 General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,

 * MA  02110-1301, USA.

 *

 * For any additional information, do not hesitate to contact us

 * at info AT gvsig.com, or visit our website www.gvsig.com.

 */

package org.gvsig.fmap.geom.operation.towkb;

import org.gvsig.fmap.geom.Geometry;

public class WKBMultyLineInLineDefinitionException extends WKBEncodingException {

	/**

	 * Generated serial version UID

	 */

	private static final long serialVersionUID = -4562404266549127771L;

	/**

	 * Key to retrieve this exception's message

	 */

	private static final String MESSAGE_KEY = "wkb_move_in_middle_of_line_exception";

	private static final String FORMAT_STRING =

		"MoveTo segment in middle of a single line";

	/**

	 * Class name of the geometry type. Should never be null in this exception

	 */

	public Geometry geometry = null;

	public WKBMultyLineInLineDefinitionException(Geometry geom) {

		super(FORMAT_STRING, MESSAGE_KEY, serialVersionUID);

		this.geometry = geom;

	}

}

/**

 * gvSIG. Desktop Geographic Information System.

 *

 * Copyright (C) 2007-2013 gvSIG Association.

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License

 * as published by the Free Software Foundation; either version 3

 * of the License, or (at your option) any later version.

 *

 * This program 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 General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,

 * MA  02110-1301, USA.

 *

 * For any additional information, do not hesitate to contact us

 * at info AT gvsig.com, or visit our website www.gvsig.com.

 */

package org.gvsig.fmap.geom.operation.towkb;

import java.awt.geom.PathIterator;

import java.io.ByteArrayOutputStream;

import java.io.DataOutputStream;

import java.io.IOException;

import java.util.ArrayList;

import java.util.List;

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.Geometry.SUBTYPES;

import org.gvsig.fmap.geom.Geometry.TYPES;

import org.gvsig.fmap.geom.aggregate.Aggregate;

import org.gvsig.fmap.geom.aggregate.MultiCurve;

import org.gvsig.fmap.geom.aggregate.MultiPoint;

import org.gvsig.fmap.geom.aggregate.MultiSurface;

import org.gvsig.fmap.geom.primitive.Curve;

import org.gvsig.fmap.geom.primitive.Point;

import org.gvsig.fmap.geom.primitive.Surface;

import org.gvsig.fmap.geom.type.GeometryType;

import org.gvsig.fmap.geom.type.GeometryTypeNotSupportedException;

public class WKBEncoder {

	public interface wkbGeometryType {

		public final static int wkbPoint = 1;

		public final static int wkbLineString = 2;

		public final static int wkbPolygon = 3;

		public final static int wkbTriangle = 17;

		public final static int wkbMultiPoint = 4;

		public final static int wkbMultiLineString = 5;

		public final static int wkbMultiPolygon = 6;

		public final static int wkbGeometryCollection = 7;

		public final static int wkbPolyhedralSurface = 15;

		public final static int wkbTIN = 16;

		public final static int wkbPointZ = 1001;

		public final static int wkbLineStringZ = 1002;

		public final static int wkbPolygonZ = 1003;

		public final static int wkbTrianglez = 1017;

		public final static int wkbMultiPointZ = 1004;

		public final static int wkbMultiLineStringZ = 1005;

		public final static int wkbMultiPolygonZ = 1006;

		public final static int wkbGeometryCollectionZ = 1007;

		public final static int wkbPolyhedralSurfaceZ = 1015;

		public final static int wkbTINZ = 1016;

		public final static int wkbPointM = 2001;

		public final static int wkbLineStringM = 2002;

		public final static int wkbPolygonM = 2003;

		public final static int wkbTriangleM = 2017;

		public final static int wkbMultiPointM = 2004;

		public final static int wkbMultiLineStringM = 2005;

		public final static int wkbMultiPolygonM = 2006;

		public final static int wkbGeometryCollectionM = 2007;

		public final static int wkbPolyhedralSurfaceM = 2015;

		public final static int wkbTINM = 2016;

		public final static int wkbPointZM = 3001;

		public final static int wkbLineStringZM = 3002;

		public final static int wkbPolygonZM = 3003;

		public final static int wkbTriangleZM = 3017;

		public final static int wkbMultiPointZM = 3004;

		public final static int wkbMultiLineStringZM = 3005;

		public final static int wkbMultiPolygonZM = 3006;

		public final static int wkbGeometryCollectionZM = 3007;

		public final static int wkbPolyhedralSurfaceZM = 3015;

		public final static int wkbTinZM = 3016;

		public final static int wkb_baseToZ = wkbPointZ - wkbPoint;

		public final static int wkb_baseToM = wkbPointM - wkbPoint;

		public final static int wkb_baseToZM = wkbPointZM - wkbPoint;

	}

	public interface wkbByteOrder {

		public final static byte wkbXDR = 0;                // Big Endian

		public final static byte wkbNDR = 1;                // Little Endian

	}

	public byte[] encode(Geometry geometry)

			throws GeometryTypeNotSupportedException,

			WKBEncodingException,

			IOException {

		ByteArrayOutputStream stream;

		if (geometry.getType() == TYPES.POINT) {

			stream = new ByteArrayOutputStream(50);

		} else {

			stream = new ByteArrayOutputStream(512);

		}

		encode(geometry, stream);

		return stream.toByteArray();

	}

	public void encode(Geometry geometry, ByteArrayOutputStream stream)

			throws GeometryTypeNotSupportedException, WKBEncodingException,

			IOException {

		encode(geometry, new DataOutputStream(stream));

	}

	public void encode(Geometry geometry, DataOutputStream stream)

			throws GeometryTypeNotSupportedException,

			WKBEncodingException,

			IOException {

		switch (geometry.getType()) {

			case TYPES.POINT:

				encodePoint(geometry, stream);

				break;

			case TYPES.MULTIPOINT:

				encodeMultiPoint(geometry, stream);

				break;

			case TYPES.ARC:

			case TYPES.CURVE:

			case TYPES.CIRCLE:

			case TYPES.ELLIPSE:

			case TYPES.ELLIPTICARC:

				encodeLineString(geometry, stream);

				break;

			case TYPES.MULTICURVE:

				encodeMultiLineString(geometry, stream);

				break;

			case TYPES.SURFACE:

				encodePolygon(geometry, stream);

				break;

			case TYPES.MULTISURFACE:

				encodeMultiPolygon(geometry, stream);

				break;

			case TYPES.AGGREGATE:

				encodeCollection(geometry, stream);

				break;

			default:

				throw new GeometryTypeNotSupportedException(geometry.getType(),

					geometry.getGeometryType().getSubType());

		}

		// FIXME geom.subtype != SUBTYPES.GEOM2D NOT SUPPORTED !!!!

		if (geometry.getGeometryType().getSubType() != SUBTYPES.GEOM2D) {

			throw new GeometryTypeNotSupportedException(geometry.getType(),

					geometry.getGeometryType().getSubType());

		}

	}

	private void encodeCollection(Geometry geometry, DataOutputStream stream)

			throws GeometryTypeNotSupportedException,

			WKBEncodingException,

			IOException {

		GeometryType geometryType = geometry.getGeometryType();

		encodeWKBGeomHead(wkbGeometryType.wkbGeometryCollection, geometryType,

				stream);

		Aggregate collection = (Aggregate) geometry;

		int nGeometries = collection.getPrimitivesNumber();

		stream.writeInt(nGeometries);

		for (int i = 0; i < nGeometries; i++) {

			encode(collection.getPrimitiveAt(i), stream);

		}

	}

	private void encodeMultiPolygon(Geometry geometry, DataOutputStream stream)

			throws GeometryTypeNotSupportedException,

			WKBPolygonNotClosedException, IOException {

		GeometryType geometryType = geometry.getGeometryType();

		encodeWKBGeomHead(wkbGeometryType.wkbMultiPolygon, geometryType, stream);

		MultiSurface surfaces = (MultiSurface) geometry;

		int nGeometries = surfaces.getPrimitivesNumber();

		stream.writeInt(nGeometries);

		for (int i = 0; i < nGeometries; i++) {

			encodePolygon(surfaces.getPrimitiveAt(i), stream);

		}

	}

	private void checkLinearRingIsClosed(Geometry geom, List linearRing)

			throws WKBPolygonNotClosedException {

		double[] first = (double[]) linearRing.get(0);

		double[] last = (double[]) linearRing.get(linearRing.size() - 1);

		for (int i = 0; i < first.length; i++) {

			if (Math.abs(first[i] - last[i]) > 0.000001) {

				throw new WKBPolygonNotClosedException(geom);

			}

		}

	}

	private List getLinearRings(Surface surface)

			throws WKBPolygonNotClosedException {

		PathIterator theIterator = surface.getPathIterator(null);

		List linearRings = new ArrayList();

		List curlinearRing = new ArrayList();

		int theType;

		double[] theData = new double[6];

		while (!theIterator.isDone()) {

			// while not done

			theType = theIterator.currentSegment(theData);

			// Populate a segment of the new

			// GeneralPathX object.

			// Process the current segment to populate a new

			// segment of the new GeneralPathX object.

			switch (theType) {

			case PathIterator.SEG_MOVETO:

				if (curlinearRing.size() != 0) {

					if (curlinearRing.size() < 4) {

						// FIXME exception

						throw new WKBPolygonNotClosedException(surface);

					}

					checkLinearRingIsClosed(surface, curlinearRing);

					linearRings.add(curlinearRing);

					curlinearRing = new ArrayList();

				}

				curlinearRing.add(new double[] { theData[0], theData[1] });

				break;

			case PathIterator.SEG_LINETO:

				curlinearRing.add(new double[] { theData[0], theData[1] });

				break;

			case PathIterator.SEG_QUADTO:

				// TODO transform to linear segments

				throw new IllegalArgumentException("SEG_QUADTO unsupported");

				// shape.quadTo(theData[0], theData[1], theData[2], theData[3]);

				// break;

			case PathIterator.SEG_CUBICTO:

				// TODO transform to linear segments

				throw new IllegalArgumentException("SEG_QUADTO unsupported");

				// shape.curveTo(theData[0], theData[1], theData[2], theData[3],

				// theData[4], theData[5]);

				// break;

			case PathIterator.SEG_CLOSE:

				curlinearRing.add(curlinearRing.get(0));

				linearRings.add(curlinearRing);

				curlinearRing = new ArrayList();

				break;

			} // end switch

			theIterator.next();

		}

		if (curlinearRing.size() != 0) {

			if (curlinearRing.size() < 4) {

				// FIXME exception

				throw new WKBPolygonNotClosedException(surface);

			}

			checkLinearRingIsClosed(surface, curlinearRing);

			linearRings.add(curlinearRing);

		}

		return linearRings;

	}

	private List getLines(Curve curve) throws WKBEncodingException {

		List lines = new ArrayList();

		PathIterator theIterator = curve.getPathIterator(null);

		List curlinearRing = new ArrayList();

		int theType;

		double[] theData = new double[6];

		while (!theIterator.isDone()) {

			// while not done

			theType = theIterator.currentSegment(theData);

			// Populate a segment of the new

			// GeneralPathX object.

			// Process the current segment to populate a new

			// segment of the new GeneralPathX object.

			switch (theType) {

			case PathIterator.SEG_MOVETO:

				if (curlinearRing.size() != 0) {

					if (curlinearRing.size() < 2) {

						throw new WKBOnePointLineException(curve);

					}

					lines.add(curlinearRing);

					curlinearRing = new ArrayList();

				}

				curlinearRing.add(new double[] { theData[0], theData[1] });

				break;

			case PathIterator.SEG_LINETO:

				curlinearRing.add(new double[] { theData[0], theData[1] });

				break;

			case PathIterator.SEG_QUADTO:

				// TODO transform to linear segments

				throw new IllegalArgumentException("SEG_QUADTO unsupported");

				// shape.quadTo(theData[0], theData[1], theData[2], theData[3]);

				// break;

			case PathIterator.SEG_CUBICTO:

				// TODO transform to linear segments

				throw new IllegalArgumentException("SEG_QUADTO unsupported");

				// shape.curveTo(theData[0], theData[1], theData[2], theData[3],

				// theData[4], theData[5]);

				// break;

			case PathIterator.SEG_CLOSE:

				curlinearRing.add(curlinearRing.get(0));

				break;

			} // end switch

			theIterator.next();

		}

		if (curlinearRing.size() != 0) {

			if (curlinearRing.size() < 2) {

				throw new WKBOnePointLineException(curve);

			}

			lines.add(curlinearRing);

		}

		return lines;

	}

	private void encodePolygon(Geometry geometry, DataOutputStream stream)

			throws GeometryTypeNotSupportedException,

			WKBPolygonNotClosedException, IOException {

		GeometryType geometryType = geometry.getGeometryType();

		encodeWKBGeomHead(wkbGeometryType.wkbPolygon, geometryType, stream);

		Surface surface = (Surface) geometry;

		List linearRings = getLinearRings(surface);

		stream.writeInt(linearRings.size());

		for (int i = 0; i < linearRings.size(); i++) {

			encodeLinearRing((List) linearRings.get(i), stream);

		}

	}

	private void encodeLinearRing(List linearRing, DataOutputStream stream)

			throws IOException {

		stream.writeInt(linearRing.size());

		for (int i = 0; i < linearRing.size(); i++) {

			encodeCoordinates((double[]) linearRing.get(i), stream);

		}

	}

	private void encodeMultiLineString(Geometry geometry,

			DataOutputStream stream)

			throws GeometryTypeNotSupportedException,

			WKBEncodingException, IOException {

		GeometryType geometryType = geometry.getGeometryType();

		encodeWKBGeomHead(wkbGeometryType.wkbMultiLineString, geometryType,

				stream);

		MultiCurve curves = (MultiCurve) geometry;

		int nGeometries = curves.getPrimitivesNumber();

		stream.writeInt(nGeometries);

		for (int i = 0; i < nGeometries; i++) {

			encodeLineString(curves.getPrimitiveAt(i), stream);

		}

	}

	private void encodeLineString(Geometry geometry, DataOutputStream stream)

			throws GeometryTypeNotSupportedException, WKBEncodingException,

			IOException {

		GeometryType geometryType = geometry.getGeometryType();

		encodeWKBGeomHead(wkbGeometryType.wkbLineString, geometryType,

				 stream);

		Curve curve = (Curve) geometry;

		List lines = getLines(curve);

		if (lines.size() != 1) {

			throw new WKBMultyLineInLineDefinitionException(curve);

		}

		List line = (List) lines.get(0);

		int nVertices = line.size();

		stream.writeInt(nVertices);

		for (int i = 0; i < nVertices; i++) {

			encodeCoordinates((double[]) line.get(i), stream);

		}

	}

	private void encodeCoordinates(double[] coordinates, DataOutputStream stream)

			throws IOException {

		for (int i = 0; i < coordinates.length; i++) {

			stream.writeDouble(coordinates[i]);

		}

	}

	private void encodeWKBGeomHead(int wkbBaseType, GeometryType geometryType,

			DataOutputStream stream) throws GeometryTypeNotSupportedException,

			IOException {

		stream.writeByte(wkbByteOrder.wkbXDR);

		int finalType = wkbBaseType % wkbGeometryType.wkb_baseToZ;

		switch (geometryType.getSubType()) {

		case SUBTYPES.GEOM2D:

			break;

		case SUBTYPES.GEOM2DM:

			finalType = finalType + wkbGeometryType.wkb_baseToM;

			break;

		case SUBTYPES.GEOM3D:

			finalType = finalType + wkbGeometryType.wkb_baseToZ;

			break;

		case SUBTYPES.GEOM3DM:

			finalType = finalType + wkbGeometryType.wkb_baseToZM;

			break;

		default:

			throw new GeometryTypeNotSupportedException(geometryType.getType(),

					geometryType.getSubType());

		}

		stream.writeInt(finalType);

	}

	private void encodePoint(Geometry geometry, DataOutputStream stream)

			throws GeometryTypeNotSupportedException, IOException {

		GeometryType geometryType = geometry.getGeometryType();

		encodeWKBGeomHead(wkbGeometryType.wkbPoint, geometryType,

				stream);

		Point point = (Point) geometry;

		double[] coords = point.getCoordinates();

		for (int i = 0; i < coords.length; i++) {

			stream.writeDouble(coords[i]);

		}

	}

	private void encodeMultiPoint(Geometry geometry, DataOutputStream stream)

			throws GeometryTypeNotSupportedException, IOException {

		GeometryType geometryType = geometry.getGeometryType();

		encodeWKBGeomHead(wkbGeometryType.wkbMultiPoint, geometryType, stream);

		MultiPoint points = (MultiPoint) geometry;

		int nGeometries = points.getPrimitivesNumber();

		stream.writeInt(nGeometries);

		for (int i=0;i<nGeometries;i++) {

			encodePoint(points.getPrimitiveAt(i), stream);

		}

	}

}

/**

 * gvSIG. Desktop Geographic Information System.

 *

 * Copyright (C) 2007-2013 gvSIG Association.

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License

 * as published by the Free Software Foundation; either version 3

 * of the License, or (at your option) any later version.

 *

 * This program 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 General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,

 * MA  02110-1301, USA.

 *

 * For any additional information, do not hesitate to contact us

 * at info AT gvsig.com, or visit our website www.gvsig.com.

 */

package org.gvsig.fmap.geom.operation.towkb;

import org.gvsig.fmap.geom.Geometry;

public class WKBPolygonNotClosedException extends WKBEncodingException {

	/**

	 * Generated serial version UID

	 */

	private static final long serialVersionUID = 2345762531238114238L;

	/**

	 * Key to retrieve this exception's message

	 */

	private static final String MESSAGE_KEY = "wkb_polygon_not_closed_exception";

	private static final String FORMAT_STRING =

		"Polygon not closed found";

	/**

	 * Class name of the geometry type. Should never be null in this exception

	 */

	public Geometry geometry = null;

	public WKBPolygonNotClosedException(Geometry geom) {

		super(FORMAT_STRING, MESSAGE_KEY, serialVersionUID);

		this.geometry = geom;

	}

}

/**

 * gvSIG. Desktop Geographic Information System.

 *

 * Copyright (C) 2007-2013 gvSIG Association.

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License

 * as published by the Free Software Foundation; either version 3

 * of the License, or (at your option) any later version.

 *

 * This program 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 General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,

 * MA  02110-1301, USA.

 *

 * For any additional information, do not hesitate to contact us

 * at info AT gvsig.com, or visit our website www.gvsig.com.

 */

package org.gvsig.fmap.geom.operation.towkb;

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.GeometryLocator;

import org.gvsig.fmap.geom.operation.GeometryOperation;

import org.gvsig.fmap.geom.operation.GeometryOperationContext;

import org.gvsig.fmap.geom.util.Converter;

import com.vividsolutions.jts.io.WKBWriter;

public class ToWKB extends GeometryOperation {

    public static final String NAME       = "toWKB";

	public static final int    CODE       =  GeometryLocator.getGeometryManager().getGeometryOperationCode(NAME);

	private static WKBWriter   writer     = null;

	private static int         dimension  = 2;

	public Object invoke(Geometry geom, GeometryOperationContext ctx) {

		int subType = geom.getGeometryType().getSubType();

		boolean is3D = subType == 1 || subType == 3;

		if(writer == null) {

			if(is3D) {

				dimension = 3;

				writer = new WKBWriter(3);

			} else {

				dimension = 2;

				writer = new WKBWriter();

			}

		} else {

			if(is3D && dimension == 2) {

				dimension = 3;

				writer = new WKBWriter(3);

			}

			if(!is3D && dimension == 3) {

				dimension = 2;

				writer = new WKBWriter();

			}

		}

		if (ctx == null) {

			return writer.write(Converter.geometryToJts(geom));

		}

		return writer.write(Converter.geometryToJtsWithSRID(geom,

				((ToWKBOperationContext) ctx).getSrID()));

	}

	public int getOperationIndex() {

		return CODE;

	}

}

/**

 * gvSIG. Desktop Geographic Information System.

 *

 * Copyright (C) 2007-2013 gvSIG Association.

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License

 * as published by the Free Software Foundation; either version 3

 * of the License, or (at your option) any later version.

 *

 * This program 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 General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,

 * MA  02110-1301, USA.

 *

 * For any additional information, do not hesitate to contact us

 * at info AT gvsig.com, or visit our website www.gvsig.com.

 */

package org.gvsig.fmap.geom.operation.towkb;

import org.gvsig.fmap.geom.Geometry;

public class WKBOnePointLineException extends WKBEncodingException {

	/**

	 * Generated serial version UID

	 */

	private static final long serialVersionUID = 1810408131264048570L;

	/**

	 * Key to retrieve this exception's message

	 */

	private static final String MESSAGE_KEY = "wkb_one_point_line_exception";

	private static final String FORMAT_STRING =

		"Single point line definition";

	/**

	 * Class name of the geometry type. Should never be null in this exception

	 */

	public Geometry geometry = null;

	public WKBOnePointLineException(Geometry geom) {

		super(FORMAT_STRING, MESSAGE_KEY, serialVersionUID);

		this.geometry = geom;

	}

}

/**

 * gvSIG. Desktop Geographic Information System.

 *

 * Copyright (C) 2007-2013 gvSIG Association.

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License

 * as published by the Free Software Foundation; either version 3

 * of the License, or (at your option) any later version.

 *

 * This program 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 General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,

 * MA  02110-1301, USA.

 *

 * For any additional information, do not hesitate to contact us

 * at info AT gvsig.com, or visit our website www.gvsig.com.

 */

package org.gvsig.fmap.geom.operation.fromwkt;

import org.gvsig.fmap.geom.operation.GeometryOperationContext;

/**

 * @author jmvivo

 * 

 */

public class FromWKTGeometryOperationContext extends GeometryOperationContext {

	public static final String SRS = "srs";

	public static final String TEXT = "text";

	public FromWKTGeometryOperationContext(String text,String srs) {

		this.setText(text);

		this.setSrs(srs);

	}

	public void setText(String text) {

		this.setAttribute(TEXT, text);

	}

	public String getText() {

		return (String) this.getAttribute(TEXT);

	}

	protected String getSrs() {

		return (String) this.getAttribute(SRS);

	}

	protected void setSrs(String srs) {

		this.setAttribute(SRS, srs);

	}

}

/**

 * gvSIG. Desktop Geographic Information System.

 *

 * Copyright (C) 2007-2013 gvSIG Association.

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License

 * as published by the Free Software Foundation; either version 3

 * of the License, or (at your option) any later version.

 *

 * This program 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 General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,

 * MA  02110-1301, USA.

 *

 * For any additional information, do not hesitate to contact us

 * at info AT gvsig.com, or visit our website www.gvsig.com.

 */

package org.gvsig.fmap.geom.operation.fromwkt;

import java.io.IOException;

import java.io.Reader;

import java.io.StreamTokenizer;

import java.io.StringReader;

import java.util.ArrayList;

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.GeometryException;

import org.gvsig.fmap.geom.GeometryLocator;

import org.gvsig.fmap.geom.GeometryManager;

import org.gvsig.fmap.geom.Geometry.SUBTYPES;

import org.gvsig.fmap.geom.Geometry.TYPES;

import org.gvsig.fmap.geom.aggregate.MultiCurve;

import org.gvsig.fmap.geom.aggregate.MultiPoint;

import org.gvsig.fmap.geom.aggregate.MultiSurface;

import org.gvsig.fmap.geom.exception.CreateGeometryException;

import org.gvsig.fmap.geom.operation.GeometryOperationException;

import org.gvsig.fmap.geom.primitive.Curve;

import org.gvsig.fmap.geom.primitive.GeneralPathX;

import org.gvsig.fmap.geom.primitive.Point;

import org.gvsig.fmap.geom.primitive.Surface;

import org.gvsig.tools.exception.BaseException;

import com.vividsolutions.jts.geom.Coordinate;

import com.vividsolutions.jts.io.ParseException;

/**

 *  Converts a Well-Known Text string to a <code>Geometry</code>.

 * <p>

 *  The <code>WKTReader</code> allows

 *  extracting <code>Geometry</code> objects from either input streams or

 *  internal strings. This allows it to function as a parser to read <code>Geometry</code>

 *  objects from text blocks embedded in other data formats (e.g. XML). <P>

 * <p>

 * The Well-known

 *  Text format is defined in the <A HREF="http://www.opengis.org/techno/specs.htm">

 *  OpenGIS Simple Features Specification for SQL</A> . <P>

 * <p>

 *  <B>Note: </B> There is an inconsistency in the SFS. The WKT grammar states

 *  that <code>MultiPoints</code> are represented by <code>MULTIPOINT ( ( x y), (x y) )</code>

 *  , but the examples show <code>MultiPoint</code>s as <code>MULTIPOINT ( x y, x y )</code>

 *  . Other implementations follow the latter syntax, so JTS will adopt it as

 *  well.

 *

 *  A <code>WKTReader</code> is parameterized by a <code>GeometryFactory</code>

 *  , to allow it to create <code>Geometry</code> objects of the appropriate

 *  implementation. In particular, the <code>GeometryFactory</code> will

 *  determine the <code>PrecisionModel</code> and <code>SRID</code> that is

 *  used. <P>

 *

 *  The <code>WKTReader</code> will convert the input numbers to the precise

 *  internal representation.

 *

 *  Reads non-standard "LINEARRING" tags.

 *

 *@version 1.5

 */

public class WKTParser {

	private GeometryManager manager = GeometryLocator.getGeometryManager();

	/**

	 * Creates a WKTReader that creates objects using a basic GeometryFactory.

	 */

	public WKTParser() {

	}

	/**

	 * Converts a Well-known Text representation to a <code>Geometry</code>.

	 * 

	 * @param wellKnownText

	 *            one or more <Geometry Tagged Text>strings (see the OpenGIS

	 *            Simple Features Specification) separated by whitespace

	 * @return a <code>Geometry</code> specified by <code>wellKnownText</code>

	 * @throws ParseException

	 *             if a parsing problem occurs

	 */

	public Geometry read(String wellKnownText) throws ParseException {

		StringReader reader = new StringReader(wellKnownText);

		try {

			return read(reader);

		}

		finally {

			reader.close();

		}

	}

	/**

	 *  Converts a Well-known Text representation to a <code>Geometry</code>.

	 *

	 *@param  reader           a Reader which will return a <Geometry Tagged Text>

	 *      string (see the OpenGIS Simple Features Specification)

	 *@return                  a <code>Geometry</code> read from <code>reader</code>

	 *@throws  ParseException  if a parsing problem occurs

	 */

	public Geometry read(Reader reader) throws ParseException {

		StreamTokenizer tokenizer = new StreamTokenizer(reader);

		try {

			return readGeometryTaggedText(tokenizer);

		}

		catch (IOException e) {

			throw new ParseException(e.toString());

		} catch (CreateGeometryException e) {

			throw new ParseException(e.toString());

		}

	}

	/**

	 *  Returns the next array of <code>Coordinate</code>s in the stream.

	 *

	 *@param  tokenizer        tokenizer over a stream of text in Well-known Text

	 *      format. The next element returned by the stream should be "(" (the

	 *      beginning of "(x1 y1, x2 y2, ..., xn yn)") or "EMPTY".

	 *@return                  the next array of <code>Coordinate</code>s in the

	 *      stream, or an empty array if "EMPTY" is the next element returned by

	 *      the stream.

	 *@throws  IOException     if an I/O error occurs

	 *@throws  ParseException  if an unexpected token was encountered

	 */

	private Coordinate[] getCoordinates(StreamTokenizer tokenizer)

	throws IOException, ParseException

	{

		String nextToken = getNextEmptyOrOpener(tokenizer);

		if (nextToken.equals("EMPTY")) {

			return new Coordinate[]{};

		}

		ArrayList coordinates = new ArrayList();

		coordinates.add(getPreciseCoordinate(tokenizer));

		nextToken = getNextCloserOrComma(tokenizer);

		while (nextToken.equals(",")) {

			coordinates.add(getPreciseCoordinate(tokenizer));

			nextToken = getNextCloserOrComma(tokenizer);

		}

		Coordinate[] array = new Coordinate[coordinates.size()];

		return (Coordinate[]) coordinates.toArray(array);

	}

	private Coordinate getPreciseCoordinate(StreamTokenizer tokenizer)

	throws IOException, ParseException

	{

		Coordinate coord = new Coordinate();

		coord.x = getNextNumber(tokenizer);

		coord.y = getNextNumber(tokenizer);

		if (isNumberNext(tokenizer)) {

			coord.z = getNextNumber(tokenizer);

		}

		return coord;

	}

	private boolean isNumberNext(StreamTokenizer tokenizer) throws IOException {

		try {

			return tokenizer.nextToken() == StreamTokenizer.TT_NUMBER;

		}

		finally {

			tokenizer.pushBack();

		}

	}

	/**

	 *  Returns the next number in the stream.

	 *

	 *@param  tokenizer        tokenizer over a stream of text in Well-known Text

	 *      format. The next token must be a number.

	 *@return                  the next number in the stream

	 *@throws  ParseException  if the next token is not a number

	 *@throws  IOException     if an I/O error occurs

	 */

	private double getNextNumber(StreamTokenizer tokenizer) throws IOException,

	ParseException {

		int type = tokenizer.nextToken();

		switch (type) {

		case StreamTokenizer.TT_EOF:

			throw new ParseException("Expected number but encountered end of stream");

		case StreamTokenizer.TT_EOL:

			throw new ParseException("Expected number but encountered end of line");

		case StreamTokenizer.TT_NUMBER:

			return tokenizer.nval;

		case StreamTokenizer.TT_WORD:

			throw new ParseException("Expected number but encountered word: " +

					tokenizer.sval);

		case '(':

			throw new ParseException("Expected number but encountered '('");

		case ')':

			throw new ParseException("Expected number but encountered ')'");

		case ',':

			throw new ParseException("Expected number but encountered ','");

		}

		return 0;

	}

	/**

	 *  Returns the next "EMPTY" or "(" in the stream as uppercase text.

	 *

	 *@param  tokenizer        tokenizer over a stream of text in Well-known Text

	 *      format. The next token must be "EMPTY" or "(".

	 *@return                  the next "EMPTY" or "(" in the stream as uppercase

	 *      text.

	 *@throws  ParseException  if the next token is not "EMPTY" or "("

	 *@throws  IOException     if an I/O error occurs

	 */

	private String getNextEmptyOrOpener(StreamTokenizer tokenizer) throws IOException, ParseException {

		String nextWord = getNextWord(tokenizer);

		if (nextWord.equals("EMPTY") || nextWord.equals("(")) {

			return nextWord;

		}

		throw new ParseException("Expected 'EMPTY' or '(' but encountered '" +

				nextWord + "'");

	}

	/**

	 *  Returns the next ")" or "," in the stream.

	 *

	 *@param  tokenizer        tokenizer over a stream of text in Well-known Text

	 *      format. The next token must be ")" or ",".

	 *@return                  the next ")" or "," in the stream

	 *@throws  ParseException  if the next token is not ")" or ","

	 *@throws  IOException     if an I/O error occurs

	 */

	private String getNextCloserOrComma(StreamTokenizer tokenizer) throws IOException, ParseException {

		String nextWord = getNextWord(tokenizer);

		if (nextWord.equals(",") || nextWord.equals(")")) {

			return nextWord;

		}

		throw new ParseException("Expected ')' or ',' but encountered '" + nextWord

				+ "'");

	}

	/**

	 *  Returns the next ")" in the stream.

	 *

	 *@param  tokenizer        tokenizer over a stream of text in Well-known Text

	 *      format. The next token must be ")".

	 *@return                  the next ")" in the stream

	 *@throws  ParseException  if the next token is not ")"

	 *@throws  IOException     if an I/O error occurs

	 */

	private String getNextCloser(StreamTokenizer tokenizer) throws IOException, ParseException {

		String nextWord = getNextWord(tokenizer);

		if (nextWord.equals(")")) {

			return nextWord;

		}

		throw new ParseException("Expected ')' but encountered '" + nextWord + "'");

	}

	/**

	 *  Returns the next word in the stream as uppercase text.

	 *

	 *@param  tokenizer        tokenizer over a stream of text in Well-known Text

	 *      format. The next token must be a word.

	 *@return                  the next word in the stream as uppercase text

	 *@throws  ParseException  if the next token is not a word

	 *@throws  IOException     if an I/O error occurs

	 */

	private String getNextWord(StreamTokenizer tokenizer) throws IOException, ParseException {

		int type = tokenizer.nextToken();

		switch (type) {

		case StreamTokenizer.TT_EOF:

			throw new ParseException("Expected word but encountered end of stream");

		case StreamTokenizer.TT_EOL:

			throw new ParseException("Expected word but encountered end of line");

		case StreamTokenizer.TT_NUMBER:

			throw new ParseException("Expected word but encountered number: " +

					tokenizer.nval);

		case StreamTokenizer.TT_WORD:

			return tokenizer.sval.toUpperCase();

		case '(':

			return "(";

		case ')':

			return ")";

		case ',':

			return ",";

		}

		// Assert.shouldNeverReachHere("Encountered unexpected StreamTokenizer type: " + type);

		return null;

	}

	/**

	 *  Creates a <code>Geometry</code> using the next token in the stream.

	 *

	 *@param  tokenizer        tokenizer over a stream of text in Well-known Text

	 *      format. The next tokens must form a <Geometry Tagged Text>.

	 *@return                  a <code>Geometry</code> specified by the next token

	 *      in the stream

	 *@throws  ParseException  if the coordinates used to create a <code>Polygon</code>

	 *      shell and holes do not form closed linestrings, or if an unexpected

	 *      token was encountered

	 *@throws  IOException     if an I/O error occurs

	 * @throws CreateGeometryException 

	 */

	private Geometry readGeometryTaggedText(StreamTokenizer tokenizer) throws IOException, ParseException, CreateGeometryException{

		String type = getNextWord(tokenizer);

		if (type.equals("POINT")) {

			return readPointText(tokenizer);

		}

		else if (type.equals("LINESTRING")) {

			return readLineStringText(tokenizer);

		}

		else if (type.equals("LINEARRING")) {

			return readLinearRingText(tokenizer);

		}

		else if (type.equals("POLYGON")) {

			return readPolygonText(tokenizer);

		}

		else if (type.equals("MULTIPOINT")) {

			return readMultiPointText(tokenizer);

		}

		else if (type.equals("MULTILINESTRING")) {

			return readMultiLineStringText(tokenizer);

		}

		else if (type.equals("MULTIPOLYGON")) {

			return readMultiPolygonText(tokenizer);

		}

		/* else if (type.equals("GEOMETRYCOLLECTION")) {

      return readGeometryCollectionText(tokenizer);

    } */

		System.err.println("Unknown type: " + type);

		throw new ParseException("Unknown type: " + type);

	}

	/**

	 *  Creates a <code>Point</code> using the next token in the stream.