Application: gvSIG desktop » gvSIG geoprocess

	private FeatureStore              store             = null;

	private String[]                  fieldNames        = null;

	private GeometryManager           geometryManager   = null;

	/**

	 * Sets the output FeatureType

	 * @param out

	 */

	public DALFeaturePersister(FeatureStore out, String[] fieldNames) {

		this.store = out;

		}

		geometryManager = GeometryLocator.getGeometryManager();

	}

	/**

	 * @return

	 */

	public String[] getFieldNames() {

		}

		return null;

	}

	/**

	 * @return

	 */

	public String[] getFieldNamesWithoutGeom() {

					break;

				}

			}

			int cont = 0;

			String[] fieldNames = new String[nFields];

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

		}

		return null;

	}

	/**

	 * Adds a JTS feature to the FeatureStore

	 * @param entry

	 * @throws CreateGeometryException

	 * @throws DataException

	 */

		throws CreateGeometryException, DataException {

		int outPutType = getOutputFeatureStore().getDefaultFeatureType()

								.getDefaultGeometryAttribute().getGeomType().getType();

		//Si el objeto que viene es un GeometryCollection hay que convertirlo a una lista de geometrias

		//solo del tipo que pueda salvarse en la capa eliminando el resto. Esto sucede sobre todo en la intersecci?n

		//que devuelve tipos mezclados. Cada uno debe salvarse en el tipo de capa de salida apropiado

			Sextante.addErrorToLog(e1);

		}

		org.gvsig.fmap.geom.Geometry newDalGeom = null;

		if(dalGeomList == null) {

			GeometryOperationContext ctx = new GeometryOperationContext();

			ctx.setAttribute(FromJTS.PARAM, newGeom);

				return null;

			}

		}

		EditableFeature feat = store.createNewFeature();

		int globalIndex = 0;

		int localIndex = 0;

		Object value = feature1.get(localIndex);

			value = feature1.get(++localIndex);

			globalIndex ++;

		}

		localIndex = 0;

		value = feature2.get(localIndex);

		while(value != null && !(value instanceof org.gvsig.fmap.geom.Geometry)) {

		}

		return null;

	}

		throws CreateGeometryException, DataException {

		EditableFeature feat = store.createNewFeature();

		int globalIndex = 0;

		int localIndex = 0;

		Object value = feature1.get(localIndex);

			value = feature1.get(++localIndex);

			globalIndex ++;

		}

		localIndex = 0;

		value = feature2.get(localIndex);

		while(value != null && !(value instanceof org.gvsig.fmap.geom.Geometry)) {

		}

		return null;

	}

	/**

	 * Converts a geometry collection from JTS to a list of geometries of the selected type.

	 * @param col

	 * @param type

	 * @return

	 */

	public ArrayList<org.gvsig.fmap.geom.Geometry> convertGeometryCollection2GeometryList(Geometry g, int type) throws GeometryOperationNotSupportedException, GeometryOperationException {

			!(g instanceof com.vividsolutions.jts.geom.MultiPolygon)) {

			GeometryCollection col = (GeometryCollection)g;

			ArrayList<org.gvsig.fmap.geom.Geometry> geometries = new ArrayList<org.gvsig.fmap.geom.Geometry>();

			if(type == TYPES.MULTIPOINT || type == TYPES.POINT) {

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

					Geometry gx = col.getGeometryN(i);

						gx instanceof com.vividsolutions.jts.geom.MultiPoint) {

						GeometryOperationContext ctx = new GeometryOperationContext();

						ctx.setAttribute(FromJTS.PARAM, gx);

					}

				}

			}

			if(type == TYPES.MULTICURVE || type == TYPES.CURVE) {

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

					Geometry gx = col.getGeometryN(i);

						gx instanceof com.vividsolutions.jts.geom.MultiLineString) {

						GeometryOperationContext ctx = new GeometryOperationContext();

						ctx.setAttribute(FromJTS.PARAM, gx);

			if(type == TYPES.MULTISURFACE || type == TYPES.SURFACE) {

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

					Geometry gx = col.getGeometryN(i);

						gx instanceof com.vividsolutions.jts.geom.MultiPolygon) {

						GeometryOperationContext ctx = new GeometryOperationContext();

						ctx.setAttribute(FromJTS.PARAM, gx);

		}

		return null;

	}

	/**

	 * Converts a geometry into a multigeometry

	 * @param g

		if(list.size() == 0)

			return null;

		MultiPrimitive primitive = null;

		if(list.get(0) instanceof Point || list.get(0) instanceof MultiPoint) {

			primitive = (MultiPrimitive)geometryManager.create(TYPES.MULTIPOINT, SUBTYPES.GEOM2D);

		}

		if(list.get(0) instanceof Surface || list.get(0) instanceof MultiSurface) {

			primitive = (MultiPrimitive)geometryManager.create(TYPES.MULTISURFACE, SUBTYPES.GEOM2D);

		}

		for (int i = 0; i < list.size(); i++) {

			org.gvsig.fmap.geom.Geometry geom = list.get(i);

			if(geom instanceof MultiPrimitive) {

				}

			} else

				primitive.addPrimitive((Primitive)list.get(i));

		return primitive;

	}

	/**

	 * Converts a geometry into a multigeometry

	 * @param g

		}

		return g;

	}

	/**

	 * Checks if the type of the feature store and the geometry are compatibles.

	 * @param store

	private boolean acceptType(FeatureStore store, org.gvsig.fmap.geom.Geometry geom) throws ReadException {

		int fType = getShapeType(store);

		int gType = geom.getType();

		if(fType == gType)

			return true;

		if( fType == org.gvsig.fmap.geom.Geometry.TYPES.MULTICURVE &&

		} catch (GeometryOperationException e1) {

			Sextante.addErrorToLog(e1);

		}

		//No era un GeometryCollection

		if(dalGeomList == null) {

			org.gvsig.fmap.geom.Geometry newDalGeom = null;

		}

		return null;

	}

	private EditableFeature insertFeatureIntoStore(Feature feature, org.gvsig.fmap.geom.Geometry newDalGeom) throws DataException {

		if(acceptType(store, newDalGeom)) {

			EditableFeature feat = store.createNewFeature(store.getDefaultFeatureType(), true);

		}

		return null;

	}

	/**

	 * Adds a JTS feature to the FeatureStore

	 * @param entry

		}

		return null;

	}

	/**

	 * Adds a JTS feature to the FeatureStore

	 * @param entry

	 */

	public EditableFeature addFeature(Feature feature, List<Geometry> newJTSListGeom) throws CreateGeometryException, DataException {

		List<org.gvsig.fmap.geom.Geometry> newDalListGeom = new ArrayList<org.gvsig.fmap.geom.Geometry>();

		for (int i = 0; i < newJTSListGeom.size(); i++) {

			newDalListGeom.add(GeometryUtil.jtsToGeom(newJTSListGeom.get(i)));

		}

		org.gvsig.fmap.geom.Geometry newMultiGeom = convertGeometryList2MultiGeometry(newDalListGeom);

		insertFeatureIntoStore(feature, newMultiGeom);

		return null;

	}

	/**

	 * Adds a JTS feature to the FeatureStore

	 * @param entry

		}

		return null;

	}

	/**

	 * Adds a geometry feature to the FeatureStore

	 * @param entry

		}

		return null;

	}

	/**

	 * Adds a geometry feature to the FeatureStore

	 * @param entry

		if(newGeom != null && acceptType(store, newGeom)) {

			EditableFeature feat = store.createNewFeature();

			for (int i = 0; i < values.size(); i++) {

			}

			feat.setGeometry("GEOMETRY", convertGeometry2MultiGeometry(newGeom));

			store.insert(feat);

		}

		return null;

	}

	/**

	 * Adds a JTS feature to the FeatureStore

	 * @param entry

		if(newDalGeom != null && acceptType(store, newDalGeom)) {

			EditableFeature feat = store.createNewFeature();

			for (int i = 0; i < values.size(); i++) {

			}

			feat.setGeometry("GEOMETRY", convertGeometry2MultiGeometry(newDalGeom));

			store.insert(feat);

		}

		return null;

	}

	/**

	 * Adds a JTS feature to the FeatureStore

	 * @param entry

		}

		return null;

	}

	/**

	 * is different to the source field structure.

	 * @param entry

	 * @param newGeom

		if(acceptType(store, newGeom)) {

			//Builds a new empty feature

			EditableFeature feat = store.createNewFeature(store.getDefaultFeatureType(), true);

			//Writes only values with the same name and data type in both features

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

				if(feature.getType().getIndex(fieldNames[i]) != -1) {

					}

				}

			}

			//Sets the geometry

			feat.setGeometry(fieldNames.length, convertGeometry2MultiGeometry(newGeom));

			store.insert(feat);

		}

		return null;

	}

	/**

	 * Adds a DAL feature to the FeatureStore

	 * @param entry

	public EditableFeature addFeature(Feature feature, org.gvsig.fmap.geom.Geometry newGeom) throws CreateGeometryException, DataException {

		if(acceptType(store, newGeom)) {

			EditableFeature feat = store.createNewFeature(store.getDefaultFeatureType(), feature);

			store.insert(feat);

			return feat;

		}

		return null;

	}

	/**

	 * Adds a DAL feature to the FeatureStore

	 * @param entry

	 */

	public EditableFeature addGeometryToExistingFeature(EditableFeature feature, org.gvsig.fmap.geom.Geometry newGeom) throws CreateGeometryException, DataException {

		//Y esto para que c... sirve?

			feature.set(fieldNames[i], feature.get(i));

		if(acceptType(store, newGeom)) {

			feature.setGeometry(fieldNames.length, newGeom);

			store.update(feature);

		}

		return null;

	}

	/**

	 * Ends the edition and closes the FeatureStore

	 */

		}

		store.dispose();

	}

	/**

	 * Gets the shape type of the selected feature store

	 * @param FeatureStore source

		int indexGeom = featureType.getDefaultGeometryAttributeIndex();

		return featureType.getAttributeDescriptor(indexGeom).getGeometryType();

	}

	@SuppressWarnings("deprecation")

	public int getType() {

		if(store == null)

		int indexGeom = featureType.getDefaultGeometryAttributeIndex();

		return featureType.getAttributeDescriptor(indexGeom).getGeometryType();

	}

	public boolean isCompatibleType(org.gvsig.fmap.geom.Geometry geom) {

		if(store == null)

			return false;

			return false;

		}

	}

	/**

	 * Gets the output FeatureStore

	 * @return