Application: gvSIG desktop » gvSIG geoprocess

		getRadioButtonTable().setVisible(false);

			nearest.setSelected(true);

	@SuppressWarnings("unchecked")

		if(e.getSource() ==  getLayers2Combo()) {

			initTable();

			//If the second layer has not numerical fields only the nearest method can be applied

			IVectorLayer lyr = getSelectedVectorLayer2();

			Class[] types = lyr.getFieldTypes();

			boolean hasNumericField = false;

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

				if(types[i] == Integer.class 

						|| types[i] == Double.class 

						|| types[i] == Float.class 

						|| types[i] == Short.class) {

					hasNumericField = true;

					break;

				}

			}

			if(!hasNumericField)

				getNearestCheck().setSelected(true);

		}

		IVectorLayer layer = getSelectedVectorLayer2();

import java.util.Iterator;

import java.util.List;

import org.gvsig.fmap.dal.exception.DataException;

import org.gvsig.fmap.dal.feature.DisposableIterator;

import org.gvsig.fmap.dal.feature.FeatureIndex;

import org.gvsig.fmap.dal.feature.FeatureIndexes;

import org.gvsig.fmap.dal.feature.FeatureSet;

import org.gvsig.fmap.dal.feature.exception.FeatureIndexException;

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

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

import org.gvsig.sextante.app.algorithm.base.util.GeometryUtil;

import org.gvsig.sextante.app.algorithm.dissolve.Summary;

import org.gvsig.sextante.app.extension.core.gvVectorLayer;

import com.vividsolutions.jts.geom.Geometry;

import es.unex.sextante.core.Sextante;

	/**

	 * Geometry.distance() is a costly operation. Thats the reason for we are

	 * only using a nearest neighbor. TODO SpatialIndex works with Rectangle2D,

	 * and this may be a simplification that drives to errors. Make additional

	 * probes to use a number of default neighbors

	 */

	static final int                  DEFAULT_NUM_NEIGBOURS = 1000;

	/**

	 * Number of neighbors that nearestFinder must found.

	 */

	int                               numOfNeighbours       = DEFAULT_NUM_NEIGBOURS;

	/**

	 * Specialized instance in nearest neighbor search.

	 */

	private FeatureIndex              index                 = null;

	private Summary                   summary               = null;

	public IntersectsSpatialJoinOperation(gvVectorLayer targetLayer, String indexName, Summary summary) {

		FeatureIndexes indexes = targetLayer.getFeatureStore().getIndexes();

		index = indexes.getFeatureIndex(indexName);

		this.summary = summary;

	}

	@SuppressWarnings("unchecked")

	public EditableFeature invoke(org.gvsig.fmap.geom.Geometry g, Feature featureInput) {

		if(g == null)

			return lastEditFeature;

		try {

			Envelope rect = g.getEnvelope();

			FeatureSet featSet = index.getNearestFeatureSet(numOfNeighbours, rect);

			double nearestDistance = Double.MAX_VALUE;

			boolean first = true;

			DisposableIterator it = featSet.iterator();

			while(it.hasNext()) {

				Feature feat = (Feature)it.next();

				if(first) {

					summary.loadDefaultSummarizes(feat);

					first = false;

				}

				List geomList = feat.getGeometries();

				if(geomList == null) {

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

					buildFeature(featureInput, feat, new Double(nearestDistance), g);

					continue;

				}

				Iterator<org.gvsig.fmap.geom.Geometry> itGeom = geomList.iterator();

				while(itGeom.hasNext()) {

					org.gvsig.fmap.geom.Geometry g2 = itGeom.next();

				    buildFeature(featureInput, feat, new Double(nearestDistance), g);

				}

			}

		} catch(FeatureIndexException e) {

			Sextante.addErrorToLog(e);

		} catch (DataException e) {

			Sextante.addErrorToLog(e);

		}

		return lastEditFeature;

	/**

	 * Builds a feature and adds it to the output file

	 * @param feat1

	 * @param feat2

	 * @param value

	 * @param g

	 * @throws DataException

	 */

	private void buildFeature(Feature feat1, Feature feat2, Object value, org.gvsig.fmap.geom.Geometry g) throws DataException {

		EditableFeature outFeat = persister.getOutputFeatureStore().createNewFeature();

		int sizeFeat1 = feat1.getType().size() - 1;

		for (int i = 0; i < sizeFeat1; i++) 

			outFeat.set(i, feat1.get(i));

		for (int i = sizeFeat1; i < sizeFeat1 + feat2.getType().size() - 1; i++) 

			outFeat.set(i, feat2.get(i - sizeFeat1));

		outFeat.set(outFeat.getType().size() - 2, value);

		try {

			persister.addFeature(outFeat, g);

		} catch (CreateGeometryException e) {

			Sextante.addErrorToLog(e);

		}

	}

	public void invoke(org.gvsig.fmap.geom.Geometry g, EditableFeature featureInput) {

import java.util.ArrayList;

import java.util.Iterator;

import org.gvsig.sextante.app.algorithm.base.core.GeometryOperation;

import org.gvsig.sextante.app.algorithm.dissolve.DissolveRule;

import org.gvsig.sextante.app.algorithm.dissolve.IDissolveRule;

import org.gvsig.sextante.app.algorithm.dissolve.Summary;

import es.unex.sextante.exceptions.UnsupportedOutputChannelException;

			FeatureSet features = null;

			features = lyr1.getFeatureStore().getFeatureSet();

			FeatureType featureType1 = features.getDefaultFeatureType();

			features = lyr2.getFeatureStore().getFeatureSet();

			FeatureType featureType2 = features.getDefaultFeatureType();

			GeometryOperation operation = null;

			FeatureStore outFeatStore = null;

				outFeatStore = buildOutPutStoreFromUnion(featureType1, 

				operation = new SpatiallyIndexedSpatialJoinOperation(lyr2, indexName + "_idx");

			} else {

				outFeatStore = buildSpatialJoinOutPutStore(featureType1,

						lyr1.getShapeType(), 

						Sextante.getText("SpatialJoin"), 

						RESULT);

				IDissolveRule rule = new DissolveRule(0, funcMap);

				Summary summary = new Summary(rule, outFeatStore.getDefaultFeatureType());

				//summary.loadDefaultSummarizes(this.feature);

				operation = new IntersectsSpatialJoinOperation(lyr2, indexName + "_idx", summary);

			operation.setProgressModel(this);

			operation.computesGeometryOperation(lyr1.getFeatureStore(), 

					outFeatStore, 

					attrNames, 

					selectedGeom, 

					true);		

	/**

	 * Builds the output FeatureStore 

	 * @param featureType

	 * @return FeatureStore

	 */

	@SuppressWarnings("unchecked")

	protected FeatureStore buildSpatialJoinOutPutStore(FeatureType featureType1,

											int shapeType,

											String sextanteLayerName, 

											String sextanteLayerLabel) {

		ArrayList<Class> typesList = new ArrayList<Class>();

		ArrayList<String> attr = new ArrayList<String>();

		Iterator it = featureType1.iterator();

		while( it.hasNext() ) {

			FeatureAttributeDescriptor attribute = (FeatureAttributeDescriptor)it.next();

			if(attribute.getName().compareTo("GEOMETRY") != 0) {

				attr.add(attribute.getName());

				typesList.add(attribute.getObjectClass());

			}

		}

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

			if(funcList[i]) {

				String fieldName = funcMap.get(Summary[i]);

				if(fieldName.length() >= 6)

					fieldName = fieldName.substring(0, 7);

				attr.add(fieldName + "_" + Summary[i]);

				typesList.add(Double.class);

			}

		}

		attr.add("NUM_RELA");

		typesList.add(Integer.class);

		attrNames = new String[attr.size()];

		attr.toArray(attrNames);

		Class[] types = new Class[typesList.size()];

		typesList.toArray(types);

		try {

			IVectorLayer output = getNewVectorLayer(sextanteLayerLabel,

													sextanteLayerName,

													shapeType, types, attrNames);

			return ((gvVectorLayer)output).getFeatureStore();

		} catch (UnsupportedOutputChannelException e) {

			Sextante.addErrorToLog(e);

		}

		return null;

	}