/ - Diff - | gvSIG desktop 1 - gvSIG

     import org.cresques.cts.ICoordTrans;
     import org.cresques.cts.IProjection;
     import org.gvsig.fmap.geom.Geometry;
     import org.gvsig.fmap.geom.GeometryManager;
     import org.gvsig.fmap.geom.aggregate.MultiPrimitive;
     import org.gvsig.fmap.geom.handler.Handler;
     import org.gvsig.fmap.geom.operation.GeometryOperationException;
     import org.gvsig.fmap.geom.primitive.Envelope;
     import org.gvsig.fmap.geom.primitive.FShape;
     import org.gvsig.fmap.geom.primitive.GeneralPathX;
     import org.gvsig.fmap.geom.primitive.Primitive;
     import org.gvsig.fmap.geom.primitive.impl.AbstractPrimitive;
     import org.gvsig.fmap.geom.type.GeometryType;
     import org.slf4j.Logger;
     import org.slf4j.LoggerFactory;
     /* gvSIG. Sistema de Informaci?n Geogr?fica de la Generalitat Valenciana
+     *
-...
     public abstract class BaseMultiPrimitive extends AbstractPrimitive implements
     		MultiPrimitive {
     	private static final long serialVersionUID = 8023609161647736932L;
     	private static final Logger logger = LoggerFactory.getLogger(GeometryManager.class);
     	protected ArrayList geometries = null;
     	/**
-...
     	 * @see java.awt.Shape#contains(double, double)
     	 */
     	public boolean contains(double x, double y) {
     		boolean bResul;
     		for (int i = 0; i < getPrimitivesNumber(); i++) {
     			bResul = ((Geometry)geometries.get(i)).contains(x, y);
     			try {
     				bResul = containsPoint(
     						(Geometry)geometries.get(i), x, y);
     			} catch (GeometryOperationException e) {
     				logger.error("While doing contains: " + e.getMessage(), e);
     				bResul = true;
+    			}
     			if (bResul)
     				return true;
+    		}
-...
     	public boolean contains(Point2D p) {
     		boolean bResul;
     		for (int i = 0; i < getPrimitivesNumber(); i++) {
     			bResul = ((Geometry)geometries.get(i)).contains(p);
     			try {
     				bResul = containsPoint(
     						(Geometry)geometries.get(i),
     						p.getX(), p.getY());
     			} catch (GeometryOperationException e) {
     				logger.error("While doing contains: " + e.getMessage(), e);
     				bResul = true;
+    			}
     			if (bResul)
     				return true;
+    		}
-...
     	public boolean contains(Rectangle2D r) {
     		boolean bResul;
     		for (int i = 0; i < getPrimitivesNumber(); i++) {
     			bResul = ((Geometry)geometries.get(i)).contains(r);
     			try {
     				bResul = containsRectangle(
     						(Geometry)geometries.get(i),
     						r.getMinX(), r.getMinY(), r.getWidth(), r.getHeight());
     			} catch (GeometryOperationException e) {
     				logger.error("While doing contains: " + e.getMessage(), e);
     				bResul = true;
+    			}
     			if (bResul)
     				return true;
+    		}
-...
     	 *      double, double, double)
     	 */
     	public boolean fastIntersects(double x, double y, double w, double h) {
     		boolean resp = false;
     		for (int i = 0; i < getPrimitivesNumber(); i++) {
     			if (((Geometry)geometries.get(i)).intersects(x, y, w, h))
     			Geometry geom = (Geometry) geometries.get(i);
     			try {
     				resp = intersectsRectangle(geom, x, y, w, h);
     			} catch (GeometryOperationException e) {
     				logger.error("While doing fast intersects: " + e.getMessage(), e);
     				resp = true;
+    			}
     			if (resp) {
     				return true;
+    			}
+    		}
     		return false;
+    	}
     	/*
     	 * (non-Javadoc)
+    	 *
-...
     	public boolean intersects(double x, double y, double w, double h) {
     		boolean bResul;
     		for (int i = 0; i < getPrimitivesNumber(); i++) {
     			bResul = ((Geometry)geometries.get(i)).contains(x, y, w, h);
     			try {
     				bResul = containsRectangle((Geometry)geometries.get(i), x, y, w, h);
     			} catch (GeometryOperationException e) {
     				logger.error("While doing contains: " + e.getMessage(), e);
     				bResul = true;
+    			}
     			if (bResul)
     				return true;
+    		}
     		return false;
+    	}
     	/*
     	 * (non-Javadoc)
+    	 *
-...
     	public void addPrimitive(Primitive primitive) {
     		geometries.add(primitive);
+    	}
+    }

     	 */
     	private void setPoints(Point2D startPoint, Point2D endPoint) {
     		Line2D line = UtilFunctions.createLine(startPoint, endPoint);
     		setGeneralPath(new GeneralPathX(line));
     		setGeneralPath(new GeneralPathX(line.getPathIterator(null)));
+    	}
     	/* (non-Javadoc)

     			double angle = UtilFunctions.getAngle(axis1Start, axis1End);
     			AffineTransform mT = AffineTransform.getRotateInstance(angle, axis1Start
     					.getX(), axis1Start.getY());
     			gp = new GeneralPathX(arc);
     			gp = new GeneralPathX(arc.getPathIterator(null));
     			gp.transform(mT);
+    		}
-...
     			double angle = UtilFunctions.getAngle(axis1Start, axis1End);
     			AffineTransform mT = AffineTransform.getRotateInstance(angle, axis1Start
     					.getX(), axis1Start.getY());
     			gp = new GeneralPathX(arc);
     			gp = new GeneralPathX(arc.getPathIterator(null));
     			gp.transform(mT);
+    		}
-...
     			double angle = UtilFunctions.getAngle(axis1Start, axis1End);
     			AffineTransform mT = AffineTransform.getRotateInstance(angle, axis1Start
     					.getX(), axis1Start.getY());
     			gp = new GeneralPathX(arc);
     			gp = new GeneralPathX(arc.getPathIterator(null));
     			gp.transform(mT);
+    		}
+    	}
-...
     				Arc2D.OPEN);
     		AffineTransform mT = AffineTransform.getRotateInstance(angle,
     				center.getX(), center.getY());
     		GeneralPathX gp = new GeneralPathX(arc);
     		GeneralPathX gp = new GeneralPathX(arc.getPathIterator(null));
     		gp.transform(mT);
     		this.gp = gp;

     			double angle = UtilFunctions.getAngle(init, end);
     			AffineTransform mT = AffineTransform.getRotateInstance(angle, init
     					.getX(), init.getY());
     			gp = new GeneralPathX(arc);
     			gp = new GeneralPathX(arc.getPathIterator(null));
     			gp.transform(mT);
+    		}
-...
     			double angle = UtilFunctions.getAngle(init, end);
     			AffineTransform mT = AffineTransform.getRotateInstance(angle, init
     					.getX(), init.getY());
     			gp = new GeneralPathX(arc);
     			gp = new GeneralPathX(arc.getPathIterator(null));
     			gp.transform(mT);
+    		}
-...
     			double angle = UtilFunctions.getAngle(init, end);
     			AffineTransform mT = AffineTransform.getRotateInstance(angle, init
     					.getX(), init.getY());
     			gp = new GeneralPathX(arc);
     			gp = new GeneralPathX(arc.getPathIterator(null));
     			gp.transform(mT);
+    		}
+    	}
-...
     		double angle = UtilFunctions.getAngle(axis1Start, axis1End);
     		AffineTransform mT = AffineTransform.getRotateInstance(angle,
     				axis1Start.getX(), axis1Start.getY());
     		GeneralPathX gp = new GeneralPathX(arc);
     		GeneralPathX gp = new GeneralPathX(arc.getPathIterator(null));
     		gp.transform(mT);
     		this.gp = new GeneralPathX(gp);
     		this.gp = new GeneralPathX(gp.getPathIterator(null));
     		this.init = axis1Start;
     		this.end = axis1End;
     		this.ydist = axis2Length;

     			Arc2D.Double arc = new Arc2D.Double(center.getX() - radio, center
     					.getY()
     					- radio, 2 * radio, 2 * radio, 0, 360, Arc2D.OPEN);
     			gp = new GeneralPathX(arc);
     			gp = new GeneralPathX(arc.getPathIterator(null));
+    		}
+    	}
-...
     			Arc2D.Double arc = new Arc2D.Double(center.getX() - radio, center
     					.getY()
     					- radio, 2 * radio, 2 * radio, 0, 360, Arc2D.OPEN);
     			gp = new GeneralPathX(arc);
     			gp = new GeneralPathX(arc.getPathIterator(null));
+    		}
+    	}
-...
     			new java.awt.geom.Arc2D.Double(center.getX() - radious, _center
     				.getY()
     				- radious, 2 * radious, 2 * radious, 0, 360, Arc2D.OPEN);
     		this.gp = new GeneralPathX(arc);
     		this.gp = new GeneralPathX(arc.getPathIterator(null));
     		this.center = _center;
     		this.radio = radious;
+    	}
-...
     			new java.awt.geom.Arc2D.Double(center.getX() - radious, center
     				.getY()
     				- radious, 2 * radious, 2 * radious, 0, 360, Arc2D.OPEN);
     		this.gp = new GeneralPathX(arc);
     		this.gp = new GeneralPathX(arc.getPathIterator(null));
     		this.center = center;
     		this.radio = radious;

branches/v2_0_0_prep/libraries/libFMap_geometries/src/org/gvsig/fmap/geom/primitive/impl/Arc2D.java
215	215	public void set(double x, double y) {
216	216	center=new Point2D.Double(x,y);
217	217	java.awt.geom.Arc2D arco = UtilFunctions.createArc(init, center, end);
218		gp = new GeneralPathX(arco);
	218	gp = new GeneralPathX(arco.getPathIterator(null));
219	219	}
220	220	}
221	221
...	...
258	258	center=UtilFunctions.getPoint(mediop,perp[1],dist);
259	259
260	260	java.awt.geom.Arc2D arco = UtilFunctions.createArc(init,center, end);
261		gp=new GeneralPathX(arco);
	261	gp=new GeneralPathX(arco.getPathIterator(null));
262	262	}
263	263	public void setPoint(Point2D p){
264	264	init=p;
...	...
313	313	center=UtilFunctions.getPoint(mediop,perp[1],dist);
314	314
315	315	java.awt.geom.Arc2D arco = UtilFunctions.createArc(init,center, end);
316		gp=new GeneralPathX(arco);
	316	gp=new GeneralPathX(arco.getPathIterator(null));
317	317	}
318	318	public void setPoint(Point2D p){
319	319	end=p;
...	...
369	369	center=UtilFunctions.getPoint(mediop,perp[1],dist);
370	370
371	371	java.awt.geom.Arc2D arco = UtilFunctions.createArc(init,center, end);
372		gp=new GeneralPathX(arco);
	372	gp=new GeneralPathX(arco.getPathIterator(null));
373	373	}
374	374	public void setPoint(Point2D p){
375	375	init=p;
...	...
393	393	}
394	394	///center=TrigonometricalFunctions.getPoint(mediop,perp[1],dist);
395	395	java.awt.geom.Arc2D arco = UtilFunctions.createArc(init,center, end);
396		gp=new GeneralPathX(arco);
	396	gp=new GeneralPathX(arco.getPathIterator(null));
397	397	}
398	398	}
399	399
...	...
436	436	center=UtilFunctions.getPoint(mediop,perp[1],dist);
437	437
438	438	java.awt.geom.Arc2D arco = UtilFunctions.createArc(init,center, end);
439		gp=new GeneralPathX(arco);
	439	gp=new GeneralPathX(arco.getPathIterator(null));
440	440	}
441	441	public void setPoint(Point2D p){
442	442	end=p;
...	...
460	460	}
461	461	///center=TrigonometricalFunctions.getPoint(mediop,perp[1],dist);
462	462	java.awt.geom.Arc2D arco = UtilFunctions.createArc(init,center, end);
463		gp=new GeneralPathX(arco);
	463	gp=new GeneralPathX(arco.getPathIterator(null));
464	464	}
465	465	}
466	466
...	...
496	496	if (arco == null) {
497	497	throw new IllegalArgumentException();
498	498	}
499		this.gp = new GeneralPathX(arco);
	499	this.gp = new GeneralPathX(arco.getPathIterator(null));
500	500	this.center = p1;
501	501	this.init = p2;
502	502	this.end = p3;

     import org.gvsig.fmap.geom.GeometryLocator;
     import org.gvsig.fmap.geom.GeometryManager;
     import org.gvsig.fmap.geom.handler.Handler;
     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.operation.GeometryOperationNotSupportedException;
     import org.gvsig.fmap.geom.operation.relationship.DefaultRelationshipGeometryOperationContext;
     import org.gvsig.fmap.geom.primitive.Envelope;
     import org.gvsig.fmap.geom.primitive.FShape;
     import org.gvsig.fmap.geom.primitive.GeneralPathX;
     import org.gvsig.fmap.geom.primitive.Primitive;
     import org.gvsig.fmap.geom.type.GeometryType;
     import org.slf4j.Logger;
     import org.slf4j.LoggerFactory;
     /* gvSIG. Sistema de Informaci?n Geogr?fica de la Generalitat Valenciana
-...
      * @author Jorge Piera Llodr? (jorge.piera@iver.es)
      */
     public abstract class AbstractPrimitive implements Primitive, FShape, Serializable {
     	private static final Logger logger = LoggerFactory.getLogger(GeometryManager.class);
     	private static final long serialVersionUID = -4334977368955260872L;
     	protected String id = null;
     	protected IProjection projection = null;
-...
     	 * @see org.gvsig.fmap.geom.Geometry#fastIntersects(double, double, double, double)
     	 */
     	public boolean fastIntersects(double x, double y, double w, double h) {
     		return intersects(x,y,w,h);
     		boolean resp = true;
     		try {
     			resp = intersectsRectangle(this, x, y, w, h);
     		} catch (GeometryOperationException e) {
     			logger.error("While doing fastintersects: " + e.getMessage(), e);
+    		}
     		return resp;
+    	}
     	/*
-...
+    	}
     	/**
     	 * Utility method
     	 * @param geometry
     	 * @param x
     	 * @param y
     	 * @return
     	 * @throws GeometryOperationException
     	 */
     	protected boolean containsPoint(Geometry geom, double x, double y) throws GeometryOperationException {
     		// exclude disjoint
     		Envelope env = geom.getEnvelope();
     		if (x > env.getMaximum(0)) return false;
     		if (y > env.getMaximum(1)) return false;
     		if (x < env.getMinimum(0)) return false;
     		if (y < env.getMinimum(1)) return false;
     		// boxes overlap, need long version
     		Geometry geompoint = null;
     		try {
     			geompoint = GeometryLocator.getGeometryManager().createPoint(x, y, SUBTYPES.GEOM2D);
     		} catch (Exception e1) {
     			throw new GeometryOperationException(geom.getType(), GeometryOperation.OPERATION_CONTAINS_CODE, e1);
+    		}
     		DefaultRelationshipGeometryOperationContext drgoc =
     			new DefaultRelationshipGeometryOperationContext(geompoint);
     		Object resp = null;
     		boolean respboolean = true;
     		try {
     			resp = geom.invokeOperation(GeometryOperation.OPERATION_CONTAINS_CODE, drgoc);
     			respboolean = ((Boolean) resp).booleanValue();
     		} catch (Exception e) {
     			throw new GeometryOperationException(geom.getType(), GeometryOperation.OPERATION_CONTAINS_CODE, e);
+    		}
     		return respboolean;
+    	}
     	/**
+    	 *
     	 * @param geometry
     	 * @param x
     	 * @param y
     	 * @param w
     	 * @param h
     	 * @return
     	 */
     	protected boolean containsRectangle(Geometry geom, double x, double y,
     			double w, double h) throws GeometryOperationException {
     		// exclude disjoint boxes
     		Envelope env = geom.getEnvelope();
     		if (x > env.getMaximum(0)) return false;
     		if ((x+w) < env.getMinimum(0)) return false;
     		if (y > env.getMaximum(1)) return false;
     		if ((y+h) < env.getMinimum(1)) return false;
     		if (w == 0 && h == 0) {
     			return  containsPoint(geom, x, y);
+    		}
     		// boxes overlap, need long version
     		Geometry rectgeom = null;
     		GeneralPathX gpx = new GeneralPathX();
     		gpx.moveTo(x, y);
     		gpx.lineTo(x+w, y);
     		gpx.lineTo(x+w, y+h);
     		gpx.lineTo(x, y+h);
     		gpx.lineTo(x, y);
     		try {
     			rectgeom = GeometryLocator.getGeometryManager().createSurface(gpx, SUBTYPES.GEOM2D);
     		} catch (Exception e1) {
     			throw new GeometryOperationException(geom.getType(), GeometryOperation.OPERATION_CONTAINS_CODE, e1);
+    		}
     		DefaultRelationshipGeometryOperationContext drgoc =
     			new DefaultRelationshipGeometryOperationContext(rectgeom);
     		Object resp = null;
     		boolean respboolean = true;
     		try {
     			resp = geom.invokeOperation(GeometryOperation.OPERATION_CONTAINS_CODE, drgoc);
     			respboolean = ((Boolean) resp).booleanValue();
     		} catch (Exception e) {
     			throw new GeometryOperationException(geom.getType(), GeometryOperation.OPERATION_CONTAINS_CODE, e);
+    		}
     		return respboolean;
+    	}
     	/**
+    	 *
     	 * @param geom
     	 * @param x
     	 * @param y
     	 * @param w
     	 * @param h
     	 * @return
     	 */
     	protected boolean intersectsRectangle(Geometry geom, double x, double y,
     			double w, double h) throws GeometryOperationException {
     		// exclude disjoint boxes
     		Envelope env = geom.getEnvelope();
     		if (x > env.getMaximum(0)) return false;
     		if ((x+w) < env.getMinimum(0)) return false;
     		if (y > env.getMaximum(1)) return false;
     		if ((y+h) < env.getMinimum(1)) return false;
     		// boxes overlap, need long version
     		Geometry rectgeom = null;
     		GeneralPathX gpx = new GeneralPathX();
     		gpx.moveTo(x, y);
     		gpx.lineTo(x+w, y);
     		gpx.lineTo(x+w, y+h);
     		gpx.lineTo(x, y+h);
     		gpx.lineTo(x, y);
     		try {
     			rectgeom = GeometryLocator.getGeometryManager().createSurface(gpx, SUBTYPES.GEOM2D);
     		} catch (Exception e1) {
     			throw new GeometryOperationException(geom.getType(), GeometryOperation.OPERATION_INTERSECTS_CODE, e1);
+    		}
     		DefaultRelationshipGeometryOperationContext drgoc =
     			new DefaultRelationshipGeometryOperationContext(rectgeom);
     		Object resp = null;
     		boolean respboolean = true;
     		try {
     			resp = geom.invokeOperation(GeometryOperation.OPERATION_INTERSECTS_CODE, drgoc);
     			respboolean = ((Boolean) resp).booleanValue();
     		} catch (Exception e) {
     			throw new GeometryOperationException(geom.getType(), GeometryOperation.OPERATION_INTERSECTS_CODE, e);
+    		}
     		return respboolean;
+    	}
+    }

          * taken from the specified <code>Shape</code> object.
          * @param s the specified <code>Shape</code> object
          */
         public GeneralPathX(Shape s) {
         public GeneralPathX(PathIterator piter) { // Shape s) {
     	// this(WIND_NON_ZERO, INIT_SIZE, INIT_SIZE);
         	this(WIND_EVEN_ODD, INIT_SIZE, INIT_SIZE);
     	PathIterator pi = s.getPathIterator(null);
     	setWindingRule(pi.getWindingRule());
     	append(pi, false);
     	// PathIterator pi = s.getPathIterator(null);
     	setWindingRule(piter.getWindingRule());
     	append(piter, false);
+        }
         private void needRoom(int newTypes, int newCoords, boolean needMove) {
-...
          * initial <code>moveTo</code> segment into a <code>lineTo</code>
          * segment to connect the new geometry to the existing path
          */
         /*
         public void append(Shape s, boolean connect) {
     	PathIterator pi = s.getPathIterator(null);
             append(pi,connect);
+        }
         */
         /**
          * Appends the geometry of the specified
-...
+    			}
+    		}
     		reset();
     		append(newGp, false);
     		append(newGp.getPathIterator(null), false);
+    	}
         /**
          * Check if the first part is CCW.

     import org.gvsig.fmap.geom.exception.CreateGeometryException;
     import org.gvsig.fmap.geom.primitive.GeneralPathX;
     import org.gvsig.fmap.geom.primitive.Surface;
     import org.gvsig.fmap.geom.primitive.impl.Point2D;
     import org.slf4j.Logger;
     import org.slf4j.LoggerFactory;
-...
     		for (int i = 0; i < mls.getNumGeometries(); i++) {
     			LineString lineString = (LineString) mls.getGeometryN(i);
     			path.append(toShape(lineString), false);
     			path.append(toShape(lineString).getPathIterator(null), false);
+    		}
     		//BasicFeatureRenderer expects LineStrings and MultiLineStrings to be
-...
     	for (int i = 0; i < mp.getNumGeometries(); i++) {
     		Polygon polygon = (Polygon) mp.getGeometryN(i);
     		path.append(toShape(polygon), false);
     		path.append(toShape(polygon).getPathIterator(null), false);
+    	}
     	//BasicFeatureRenderer expects LineStrings and MultiLineStrings to be

     package org.gvsig.fmap.geom.operation;
     import org.gvsig.fmap.geom.Geometry;
     import org.gvsig.fmap.geom.GeometryLocator;
     /**
      * Every geometry operation that is registered dynamically must extend this class.<br>
-...
      */
     public abstract class GeometryOperation {
     	// Constants for well-known operations to avoid dependency between geometry model and
     	// operations.
     	public static final String OPERATION_INTERSECTS_NAME = "intersects";
     	public static final String OPERATION_CONTAINS_NAME = "contains";
     	public static int OPERATION_INTERSECTS_CODE =
     		GeometryLocator.getGeometryManager().getGeometryOperationCode(OPERATION_INTERSECTS_NAME);;
     	public static int OPERATION_CONTAINS_CODE =
     		GeometryLocator.getGeometryManager().getGeometryOperationCode(OPERATION_CONTAINS_NAME);;
     	/**
     	 * Invokes this operation given the geometry and context
     	 * @param geom Geometry to which apply this operation

branches/v2_0_0_prep/libraries/libFMap_geometries/src/org/gvsig/fmap/geom/operation/flip/Flip.java
81	81	}
82	82	}
83	83	generalPathX.reset();
84		generalPathX.append(newGp, false);
	84	generalPathX.append(newGp.getPathIterator(null), false);
85	85
86	86	return null;
87	87	}

     import org.cresques.cts.ICoordTrans;
     import org.gvsig.fmap.geom.Geometry;
     import org.gvsig.fmap.geom.GeometryLocator;
     import org.gvsig.fmap.geom.GeometryManager;
     import org.gvsig.fmap.geom.Geometry.SUBTYPES;
     import org.gvsig.fmap.geom.handler.Handler;
     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.operation.GeometryOperationNotSupportedException;
     import org.gvsig.fmap.geom.operation.relationship.DefaultRelationshipGeometryOperationContext;
     import org.gvsig.fmap.geom.primitive.Envelope;
     import org.gvsig.fmap.geom.primitive.FShape;
     import org.gvsig.fmap.geom.primitive.GeneralPathX;
     import org.gvsig.fmap.geom.primitive.Primitive;
     import org.gvsig.fmap.geom.type.GeometryType;
     import org.slf4j.Logger;
     import org.slf4j.LoggerFactory;
     /**
      * @author <a href="mailto:jpiera@gvsig.org">Jorge Piera</a>
      */
     public class Geometry2D implements Geometry{
     	private static final Logger logger = LoggerFactory.getLogger(GeometryManager.class);
     	private Geometry geometry = null;
     	/**
-...
     	 * @see java.awt.Shape#contains(java.awt.geom.Point2D)
     	 */
     	public boolean contains(Point2D p) {
     		return geometry.contains(p);
     		try {
     			return containsPoint(geometry, p.getX(), p.getY());
     		} catch (GeometryOperationException e) {
     			logger.error("While doing contains: " + e.getMessage(), e);
     			return true;
+    		}
+    	}
     	/* (non-Javadoc)
     	 * @see java.awt.Shape#contains(java.awt.geom.Rectangle2D)
     	 */
     	public boolean contains(Rectangle2D r) {
     		return geometry.contains(r);
     		try {
     			return containsRectangle(geometry,
     					r.getMinX(),
     					r.getMinY(),
     					r.getWidth(),
     					r.getHeight());
     		} catch (GeometryOperationException e) {
     			logger.error("While doing contains: " + e.getMessage(), e);
     			return true;
+    		}
+    	}
     	/* (non-Javadoc)
     	 * @see java.awt.Shape#contains(double, double)
     	 */
     	public boolean contains(double x, double y) {
     		return geometry.contains(x, y);
     		try {
     			return containsPoint(geometry, x, y);
     		} catch (GeometryOperationException e) {
     			logger.error("While doing contains: " + e.getMessage(), e);
     			return true;
+    		}
+    	}
     	/* (non-Javadoc)
     	 * @see java.awt.Shape#contains(double, double, double, double)
     	 */
     	public boolean contains(double x, double y, double w, double h) {
     		return geometry.contains(x, y, w, h);
     		try {
     			return containsRectangle(geometry, x, y, w, h);
     		} catch (GeometryOperationException e) {
     			logger.error("While doing contains: " + e.getMessage(), e);
     			return true;
+    		}
+    	}
     	/* (non-Javadoc)
-...
     	 * @see java.awt.Shape#intersects(double, double, double, double)
     	 */
     	public boolean intersects(double x, double y, double w, double h) {
     		return geometry.intersects(x, y, w, h);
     		try {
     			return intersectsRectangle(geometry, x, y, w, h);
     		} catch (GeometryOperationException e) {
     			logger.error("While doing intersects: " + e.getMessage(), e);
     			return true;
+    		}
+    	}
     	/* (non-Javadoc)
-...
     		return geometry.compareTo(arg0);
+    	}
     	/**
     	 * Utility method
     	 * @param geometry
     	 * @param x
     	 * @param y
     	 * @return
     	 * @throws GeometryOperationException
     	 */
     	protected boolean containsPoint(Geometry geom, double x, double y) throws GeometryOperationException {
     		// exclude disjoint
     		Envelope env = geom.getEnvelope();
     		if (x > env.getMaximum(0)) return false;
     		if (y > env.getMaximum(1)) return false;
     		if (x < env.getMinimum(0)) return false;
     		if (y < env.getMinimum(1)) return false;
     		// boxes overlap, need long version
     		Geometry geompoint = null;
     		try {
     			geompoint = GeometryLocator.getGeometryManager().createPoint(x, y, SUBTYPES.GEOM2D);
     		} catch (Exception e1) {
     			throw new GeometryOperationException(geom.getType(), GeometryOperation.OPERATION_CONTAINS_CODE, e1);
+    		}
     		DefaultRelationshipGeometryOperationContext drgoc =
     			new DefaultRelationshipGeometryOperationContext(geompoint);
     		Object resp = null;
     		boolean respboolean = true;
     		try {
     			resp = geom.invokeOperation(GeometryOperation.OPERATION_CONTAINS_CODE, drgoc);
     			respboolean = ((Boolean) resp).booleanValue();
     		} catch (Exception e) {
     			throw new GeometryOperationException(geom.getType(), GeometryOperation.OPERATION_CONTAINS_CODE, e);
+    		}
     		return respboolean;
+    	}
     	/**
+    	 *
     	 * @param geometry
     	 * @param x
     	 * @param y
     	 * @param w
     	 * @param h
     	 * @return
     	 */
     	protected boolean containsRectangle(Geometry geom, double x, double y,
     			double w, double h) throws GeometryOperationException {
     		// exclude disjoint boxes
     		Envelope env = geom.getEnvelope();
     		if (x > env.getMaximum(0)) return false;
     		if ((x+w) < env.getMinimum(0)) return false;
     		if (y > env.getMaximum(1)) return false;
     		if ((y+h) < env.getMinimum(1)) return false;
     		if (w == 0 && h == 0) {
     			return  containsPoint(geom, x, y);
+    		}
     		// boxes overlap, need long version
     		Geometry rectgeom = null;
     		GeneralPathX gpx = new GeneralPathX();
     		gpx.moveTo(x, y);
     		gpx.lineTo(x+w, y);
     		gpx.lineTo(x+w, y+h);
     		gpx.lineTo(x, y+h);
     		gpx.lineTo(x, y);
     		try {
     			rectgeom = GeometryLocator.getGeometryManager().createSurface(gpx, SUBTYPES.GEOM2D);
     		} catch (Exception e1) {
     			throw new GeometryOperationException(geom.getType(), GeometryOperation.OPERATION_CONTAINS_CODE, e1);
+    		}
     		DefaultRelationshipGeometryOperationContext drgoc =
     			new DefaultRelationshipGeometryOperationContext(rectgeom);
     		Object resp = null;
     		boolean respboolean = true;
     		try {
     			resp = geom.invokeOperation(GeometryOperation.OPERATION_CONTAINS_CODE, drgoc);
     			respboolean = ((Boolean) resp).booleanValue();
     		} catch (Exception e) {
     			throw new GeometryOperationException(geom.getType(), GeometryOperation.OPERATION_CONTAINS_CODE, e);
+    		}
     		return respboolean;
+    	}
     	/**
+    	 *
     	 * @param geom
     	 * @param x
     	 * @param y
     	 * @param w
     	 * @param h
     	 * @return
     	 */
     	protected boolean intersectsRectangle(Geometry geom, double x, double y,
     			double w, double h) throws GeometryOperationException {
     		// exclude disjoint boxes
     		Envelope env = geom.getEnvelope();
     		if (x > env.getMaximum(0)) return false;
     		if ((x+w) < env.getMinimum(0)) return false;
     		if (y > env.getMaximum(1)) return false;
     		if ((y+h) < env.getMinimum(1)) return false;
     		// boxes overlap, need long version
     		Geometry rectgeom = null;
     		GeneralPathX gpx = new GeneralPathX();
     		gpx.moveTo(x, y);
     		gpx.lineTo(x+w, y);
     		gpx.lineTo(x+w, y+h);
     		gpx.lineTo(x, y+h);
     		gpx.lineTo(x, y);
     		try {
     			rectgeom = GeometryLocator.getGeometryManager().createSurface(gpx, SUBTYPES.GEOM2D);
     		} catch (Exception e1) {
     			throw new GeometryOperationException(geom.getType(), GeometryOperation.OPERATION_INTERSECTS_CODE, e1);
+    		}
     		DefaultRelationshipGeometryOperationContext drgoc =
     			new DefaultRelationshipGeometryOperationContext(rectgeom);
     		Object resp = null;
     		boolean respboolean = true;
     		try {
     			resp = geom.invokeOperation(GeometryOperation.OPERATION_INTERSECTS_CODE, drgoc);
     			respboolean = ((Boolean) resp).booleanValue();
     		} catch (Exception e) {
     			throw new GeometryOperationException(geom.getType(), GeometryOperation.OPERATION_INTERSECTS_CODE, e);
+    		}
     		return respboolean;
+    	}
+    }

     						<artifactId>maven-compiler-plugin</artifactId>
     						<configuration>
     							<excludes>
     								<exclude>**/operation/*/*</exclude>
     								<exclude>**/operation/fromwkb/*</exclude>
     								<exclude>**/operation/impl/*</exclude>
     							</excludes>
     							<testExcludes>
     								<exclude>**/operation/*/*</exclude>
     								<exclude>**/**</exclude>
     							</testExcludes>
     						</configuration>
     					</plugin>
     					<plugin>
-...
     						<groupId>org.apache.maven.plugins</groupId>
     						<artifactId>maven-jar-plugin</artifactId>
     						<configuration>
     							<includes>
     								<include>**/**</include>
     							</includes>
     							<excludes>
     								<exclude>**/operation/*/*</exclude>
     								<exclude>**/impl/**</exclude>
     								<exclude>**/operation/distance/*</exclude>
     								<exclude>**/operation/ensureOrientation/*</exclude>
     								<exclude>**/operation/flip/*</exclude>
     								<exclude>**/operation/fromwkb/*</exclude>
     								<exclude>**/operation/fromwkt/*</exclude>
     								<exclude>**/operation/impl/*</exclude>
     								<exclude>**/operation/isCCW/*</exclude>
     								<exclude>**/operation/relationship/*</exclude>
     								<exclude>**/operation/tojts/*</exclude>
     								<exclude>**/operation/towkb/*</exclude>
     								<exclude>**/operation/towkt/*</exclude>
     								<exclude>**/operation/utils/*</exclude>
     								<!--  <exclude>**/impl/**</exclude> -->
     							</excludes>
     						</configuration>
     						<executions>
-...
     								</goals>
     								<configuration>
     									<classifier>impl</classifier>
     									<includes>
     										<include>**/impl/**</include>
     									</includes>
     									<excludes>
     										<exclude>**/operation/impl/**</exclude>
     									</excludes>
     									<includes>
     										<include>**/impl/**</include>
     									</includes>
     								</configuration>
     							</execution>
     							<execution>
     								<id>operation</id>
     								<phase>package</phase>
-...
     								</goals>
     								<configuration>
     									<classifier>operation</classifier>
     									<excludes>
     										<exclude>**/operation/fromwkb/**</exclude>
     									</excludes>
     									<includes>
     										<include>**/operation/*/*</include>
     									</includes>
     									<excludes>
     										<exclude>**/operation/fromwkb/*</exclude>
     									</excludes>
     								</configuration>
     							</execution>
     						</executions>
     					</plugin>
     				</plugins>

| gvSIG desktop 1

Revision 29972