Application: gvSIG desktop » gvSIG geoprocess

 */

public class FuseSpatiallyOperationFast2 extends GeometryOperation {

	private static Logger 			         logger    		    = LoggerFactory.getLogger(FuseSpatiallyOperationFast2.class.getName());

	private String                           nameIdField        = null;

	private FeatureStore                     outFeatStoreTable  = null;

	private NodeTree                         baseTree           = null;

	class Element {

		public int                 id              = -1;

		public Feature             feat            = null;

		public boolean             insertedToJoin  = false;

		public Geometry            jtsGeom         = null;

	}

	class NodeTree {

		public Element       element     = null;

		public int           pos         = 0;

		public NodeTree       parent      = null;

		public NodeTree(Element node, NodeTree parent) {

			this.element = node;

			this.parent = parent;

		}

		public Element getNext() {

			if(pos < element.overlapList.size())

				return element.overlapList.get(pos++);

			return null;

		}

	}

	public FuseSpatiallyOperationFast2(AbstractSextanteGeoProcess process) {

		super(process);

		featureList = new ArrayList<Element>();

	public void invoke(org.gvsig.fmap.geom.Geometry g,

			EditableFeature featureInput) {

		// TODO Auto-generated method stub

	}

	/**

	 * Computes a complete operation over the input FeatureStore. The result of this operation

	 * is stored in the output FeatureStore. This method will call once for each geometry.

	 *        Input FeatureStore

	 * @param outFeatStore

	 *        Output FeatureStore

	 * @param attrNames

	 *        List of attributes to build the output feature store

	 * @param selectedGeom

	 *        If it is true only the selected geometries will be processed

	 * @throws DataException

		this.selectedGeomOverlay = selectedGeomOutput;

		FeatureSet featuresSet = null;

		featuresSet = inFeatStore.getFeatureSet();

		setFeatureStore(outFeatStore, attrNames);

		Iterator it = null;

			it = featuresSet.iterator();

			numberOfFeatures = (int)featuresSet.getSize();

		}

            status.setRangeOfValues(0, numberOfFeatures);

            process.setProgress(0, numberOfFeatures);

        //Crear lista de elementos

		int iCount = 0;

		while( it.hasNext() && !process.getTaskMonitor().isCanceled()) {

			Element el = new Element();

			el.feat = feat;

			el.id = iCount;

			featureList.add(el);

                status.setCurValue(iCount);

                process.setProgress(iCount, numberOfFeatures);

			iCount ++;

		}

//		it.dispose();

		//Crear listas de solapes para cada feature

		iCount = 0;

		while (iCount < featureList.size() && !process.getTaskMonitor().isCanceled()) {

			Element elem1 = featureList.get(iCount);

			org.gvsig.fmap.geom.Geometry geom1 = elem1.feat.getDefaultGeometry();

                status.setCurValue(iCount);

            if(process != null)

                process.setProgress(iCount, numberOfFeatures);

			for (int i = iCount + 1; i < featureList.size(); i++) {

				Element elem2 = featureList.get(i);

				org.gvsig.fmap.geom.Geometry geom2 = elem2.feat.getDefaultGeometry();

				if(areBBoxesOverlaping(geom1, geom2)) {

						elem1.jtsGeom = GeometryUtil.geomToJTS(geom1);

					elem2.jtsGeom = GeometryUtil.geomToJTS(geom2);

					if(elem1.jtsGeom.intersects(elem2.jtsGeom))	{

						elem1.overlapList.add(elem2);

			}

			iCount ++;

		}

		iCount = 0;

		int iFeat = 0;

		while (iCount < featureList.size() && !process.getTaskMonitor().isCanceled()) {

			Element elem1 = featureList.get(iCount);

                status.setCurValue(iCount);

                process.setProgress(iCount, numberOfFeatures);

			if(!elem1.insertedToJoin) {

				buildListToJoin(elem1, iFeat);

				iFeat ++;

			}

			iCount ++;

		}

		if(persister != null)

			persister.end();

	}

	private boolean areBBoxesOverlaping(org.gvsig.fmap.geom.Geometry g1, org.gvsig.fmap.geom.Geometry g2) {

		if(g1.getEnvelope().getMaximum(0) < g2.getEnvelope().getMinimum(0))

			return false;

			return false;

		return true;

	}

	/**

	 * Computes the union of the list of geometries

	 * @param listResult

				newGeom = GeometryUtil.geometryUnion(result, elem1.feat.getDefaultGeometry().getGeometryType().getType());

			}

		} else {

		}

		return newGeom;

	}

	private Geometry computesUnion2(List<Geometry> listResult, Element elem1) {

		Geometry newGeom = null;

		for (int i = 1; i < listResult.size(); i++) {

		}

		return newGeom;

	}

	private Geometry computesUnion3(List<Geometry> listResult) {

		Geometry newGeom = null;

		int iCount = 0;

			process.setName("Generating union");

		while(listResult.size() > 1) {

			List<Geometry> list = new ArrayList<Geometry>();

                status.setCurValue(iCount);

            if(process != null)

                process.setProgress(iCount, max);

		}

		return newGeom;

	}

	/**

	 * Splits the array of geometries to compute its union because JTS cannot support

	 * a lot of geometries

		}

		return l;

	}

	/**

	 * @param listResult

	 * @param listToJoin

	 */

	private void buildListToJoin(Element elem, int iFeat) {

		Geometry newGeom = null;

		if(elem.overlapList.size() == 0) {

			if(!elem.insertedToJoin)

				elem.insertedToJoin = true;

					}

					subtree.element.insertedToJoin = true;

				}

				boolean back = false;

				Element l = subtree.getNext();

					back = true;

				while(!back && l.insertedToJoin) {

					l = subtree.getNext();

						back = true;

				}

				if(back) {

					subtree = subtree.parent;

					continue;

				subtree = new NodeTree(l, subtree);

			}

			newGeom = computesUnion3(listResult);

			try {

				addFeatureToOutput(newGeom, elem.feat, iFeat);

			} catch (DataException e) {

				logger.info("Error a?adiendo geometr?a", e);

			}

		}

	}

	/**

	 * Adds a feature to the output

	 * @param newGeom

	 * @throws DataException

	 * @throws CreateGeometryException

	 */

			int newFeatID) throws DataException, CreateGeometryException {

		//Si hay una tabla aparte esta capa solo lleva el id como referencia a la tabla de campos

			lastEditFeature = persister.addFeature(newGeom, nameIdField, newFeatID);

		} else {

			//Si no hay tabla se ponen todos los campos de la tabla de entrada

			lastEditFeature = persister.addFeature(newGeom, fields, values);

		}

	}

	/**

	 * Adds a feature to the output

	 * @param newGeom

	 * @throws DataException

	 * @throws CreateGeometryException

	 */

			int newFeatID) throws DataException, CreateGeometryException {

		//Si hay una tabla aparte esta capa solo lleva el id como referencia a la tabla de campos

			lastEditFeature = persister.addFeature(newGeom, nameIdField, newFeatID);

		} else {

			//Si no hay tabla se ponen todos los campos de la tabla de entrada

			lastEditFeature = persister.addFeature(newGeom, fields, values);

		}

	}

	/**

	 * exists a field that is an identifier which is a reference to the fusion layer.

	 * @param outFeatureStoreTable

	 * @param f

		}

		outFeatureStoreTable.insert(edFeat);

	}

}