| gvSIG desktop 1

/*

 * Created on 10-abr-2006

 *

 * gvSIG. Sistema de Informaci?n Geogr?fica de la Generalitat Valenciana

 *

 * Copyright (C) 2004 IVER T.I. and Generalitat Valenciana.

 *

 * 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 2

 * 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., 59 Temple Place - Suite 330, Boston, MA  02111-1307,USA.

 *

 * For more information, contact:

 *

 *  Generalitat Valenciana

 *   Conselleria d'Infraestructures i Transport

 *   Av. Blasco Ib??ez, 50

 *   46010 VALENCIA

 *   SPAIN

 *

 *      +34 963862235

 *   gvsig@gva.es

 *      www.gvsig.gva.es

 *

 *    or

 *

 *   IVER T.I. S.A

 *   Salamanca 50

 *   46005 Valencia

 *   Spain

 *

 *   +34 963163400

 *   dac@iver.es

 */

/* CVS MESSAGES:

*

* $Id: 

* $Log: 

*/

package org.gvsig.topology.topologyrules;

import java.awt.geom.Rectangle2D;

import java.util.ArrayList;

import org.gvsig.fmap.core.FGeometryUtil;

import org.gvsig.jts.JtsUtil;

import org.gvsig.topology.ITwoLyrRule;

import org.gvsig.topology.Messages;

import org.gvsig.topology.Topology;

import org.gvsig.topology.TopologyError;

import com.hardcode.gdbms.driver.exceptions.ReadDriverException;

import com.iver.cit.gvsig.fmap.core.IFeature;

import com.iver.cit.gvsig.fmap.core.IGeometry;

import com.iver.cit.gvsig.fmap.core.v02.FConverter;

import com.iver.cit.gvsig.fmap.drivers.IFeatureIterator;

import com.iver.cit.gvsig.fmap.layers.FLyrVect;

import com.vividsolutions.jts.geom.Envelope;

import com.vividsolutions.jts.geom.Geometry;

import com.vividsolutions.jts.geom.GeometryCollection;

import com.vividsolutions.jts.geom.MultiPolygon;

import com.vividsolutions.jts.geom.Polygon;

import com.vividsolutions.jts.precision.EnhancedPrecisionOp;

public class PolygonMustNotOverlapWith extends PolygonsMustNotOverlap 

										implements ITwoLyrRule{

	String ruleName = Messages.getText("must_not_overlap_with");

	FLyrVect destinationLyr;

	/**

	 * Constructor.

	 * 

	 * @param topology

	 * @param originLyr

	 * @param destinationLyr

	 * @param clusterTolerance

	 */

	public PolygonMustNotOverlapWith(Topology topology, 

									 FLyrVect originLyr,

									 FLyrVect destinationLyr,

									 double clusterTolerance){

		super(topology, originLyr, clusterTolerance);

		setDestinationLyr(destinationLyr);

	}

	protected void process(Geometry geometry, IFeature feature) {

		if (geometry instanceof GeometryCollection) {

			GeometryCollection geomCol = (GeometryCollection) geometry;

			for (int i = 0; i < geomCol.getNumGeometries(); i++) {

				Geometry geomI = geomCol.getGeometryN(i);

				process(geomI, feature);

			}

		} else if (geometry instanceof Polygon) {

			Polygon polygon = (Polygon) geometry;

			Envelope env1 = polygon.getEnvelopeInternal();

			// We try to extend a bit the original envelope to ensure

			// recovering geometries in the limit

			double delta = getClusterTolerance() + 10;

			double minX = env1.getMinX() - delta;

			double minY = env1.getMinY() - delta;

			double maxX = env1.getMaxX() + delta;

			double maxY = env1.getMaxY() + delta;

			Rectangle2D rect = new Rectangle2D.Double(minX, minY, maxX - minX,

					maxY - minY);

			try {

				IFeatureIterator neighbours = destinationLyr.

													getSource().

													getFeatureIterator(rect, null, null, false);

				while (neighbours.hasNext()) {

					IFeature neighbourFeature = neighbours.next();

					if (neighbourFeature.getID().equalsIgnoreCase(

							feature.getID()))

						continue;

					IGeometry geom2 = neighbourFeature.getGeometry();

					Rectangle2D rect2 = geom2.getBounds2D();

					if (rect.intersects(rect2)) {

						Geometry jts2 = geom2.toJTSGeometry();

						ArrayList<Polygon> geometriesToProcess = new ArrayList<Polygon>();

						if (jts2 instanceof Polygon) {

							geometriesToProcess.add((Polygon) jts2);

						} else if (jts2 instanceof MultiPolygon) {

							MultiPolygon multiPolygon = (MultiPolygon) jts2;

							int numLines = multiPolygon.getNumGeometries();

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

								Polygon polygon2 = (Polygon) multiPolygon

										.getGeometryN(i);

								geometriesToProcess.add(polygon2);

							}

						} else if (jts2 instanceof GeometryCollection) {

							MultiPolygon multiPoly = JtsUtil

									.convertToMultiPolygon((GeometryCollection) jts2);

							int numPolys = multiPoly.getNumGeometries();

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

								Polygon line = (Polygon) multiPoly

										.getGeometryN(i);

								geometriesToProcess.add(line);

							}

						} else {

							System.out.println("Encontrado:" + jts2.toString()

									+ " en regla PolygonsMustNotOverlap");

						}

						int numGeometries = geometriesToProcess.size();

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

							Polygon poly2 = geometriesToProcess.get(i);

								if(poly2.overlaps(polygon)){

									ComputedTopologyError errorEntry = 

										new ComputedTopologyError();

									errorEntry.firstFeature = feature.getID();

									errorEntry.secondFeature = neighbourFeature.getID();

									if(this.errorEntries.get(errorEntry) == null){

										Geometry errorGeomJts = EnhancedPrecisionOp.intersection(poly2, polygon);

										IGeometry errorGeom = FConverter.jts_to_igeometry(errorGeomJts);

										TopologyError topologyError = 

											new TopologyError(errorGeom, 

														errorContainer.getErrorFid(), 

														this,  

														feature, 

														neighbourFeature, 

														topology );

										addTopologyError(topologyError);

										errorEntries.put(errorEntry, errorEntry);

									}//if

								}//if

						}// for

					}//if

				}// while

			} catch (ReadDriverException e) {

				e.printStackTrace();

				return;

			}

		} else {

			System.out.println("Encontrado:" + geometry.toString()

					+ " en regla de dangles");

		}

	}

	public boolean acceptsDestinationLyr(FLyrVect destLyr) {

		try {

			int shapeType = destLyr.getShapeType();

			return (FGeometryUtil.getDimensions(shapeType) == 2);

		} catch (ReadDriverException e) {

			e.printStackTrace();

			return false;

		}

	}

	public FLyrVect getDestinationLyr() {

		return destinationLyr;

	}

	public void setDestinationLyr(FLyrVect destinationLyr) {

		this.destinationLyr = destinationLyr;

	}

}