Application: gvSIG desktop » gvSIG geoprocess

			Sextante.addErrorToLog(e);

		}

	}

	public void setParentProcess(AbstractSextanteGeoProcess process) {

		this.process = process;

	}

	/*

	 * (non-Javadoc)

	 * @see es.unex.sextante.core.GeoAlgorithm#processAlgorithm()

	 */

	public boolean processAlgorithm() throws GeoAlgorithmExecutionException {

		if(existsOutPutFile(DissolveAlgorithm.RESULT, 0)) {

    		throw new GeoAlgorithmExecutionException(getTranslation("file_exists"));

    	}

		IVectorLayer layer = m_Parameters.getParameterValueAsVectorLayer(LAYER);

		boolean selectedGeom = m_Parameters.getParameterValueAsBoolean(SELECTED_GEOM);

		FeatureStore storeLayer = null;

		if(layer instanceof FlyrVectIVectorLayer)

			storeLayer = ((FlyrVectIVectorLayer)layer).getFeatureStore();

		else

			return false;

		try {

			String[] attrNames = new String[]{"FID"};

			Class[] types = new Class[] {Integer.class};

			FeatureStore outFeatStore = buildFuseSpatiallyOutPutStore(attrNames, types,

					layer.getShapeType(), getTranslation("fusespatially"), RESULT);

			return execute(storeLayer, outFeatStore, layer.getShapeType(), selectedGeom, getStatus(), "FID", true);

		} catch (DataException e) {

			Sextante.addErrorToLog(e);

			return false;

		}

	}

			FeatureStore outFeatStore,

			String idField,

			boolean createTable) throws DataException {

		FeatureStore outFeatStoreTable = null;

				attrNamesTable[i + 1] = attrDesc.getName();

				typesTable[i + 1] = attrDesc.getDataType().getDefaultClass();

			}

			attrNamesTable = checkFields(attrNamesTable);

			outFeatStoreTable = buildFuseSpatiallyOutPutStore(attrNamesTable, typesTable,

				shapeType, getTranslation("fusespatially") + "_Table", RESULT_TABLE);

		FuseSpatiallyOperationFast2 operation = new FuseSpatiallyOperationFast2(this);

		operation.setTaskStatus(getStatus());

				outFeatStoreTable,

				attrNamesTable,

				selectedGeom,

				false,

				idField);

		if(getTaskMonitor().isCanceled())

			return false;

				attrNames, attrNamesTable, selectedGeom, status, idField);*/

		return true;

	}

	/**

	 * Removes duplicate fields

	 * @param names

		}

		return names;

	}

	/**

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

		} else {

			featuresSet = inFeatStore.getFeatureSet();

		}

		it = featuresSet.iterator();

		int numberOfFeatures = (int)featuresSet.getSize();

        if (status != null) {

            status.setRangeOfValues(0, numberOfFeatures);

        }

        //Stack<Feature> featList = new Stack<Feature>();

        List<Feature> featList = new ArrayList<Feature>();

		while( it.hasNext() ) {

			featList.add(feature);

		}

				this);

		operation.setFeatureStore(outFeatStore, attrNames);

		int size = featList.size();

		operation.setGeoProcess(this, size);

		while (featList.size() > 0 && !m_Task.isCanceled()) {

			operation.invoke(f.getDefaultGeometry(), f);

			setProgress(size - featList.size(), size);

		}

		if(operation.getWriter() != null)

			operation.getWriter().end();

	}

	public boolean setProgress(int step, int size) {

		if(process != null)

			return process.setProgress(step, size);

		else

			return super.setProgress(step, size);

	}

	/**

	 * @param featureType

	 * @return FeatureStore

	 */

	protected FeatureStore buildFuseSpatiallyOutPutStore(String[] attrNames,

											Class[] types,

											int shapeType,

											String sextanteLayerLabel) {

		try {

			IVectorLayer output = getNewVectorLayer(sextanteLayerLabel,

													sextanteLayerName,

 */

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);

	}

}