| gvSIG desktop 1

 *

 * $Id$

 * $Log$

 *

 * Revision 1.54  2006/06/01 16:15:16  fjp

 * Escritura que permite crear drivers de manera m?s sencilla.

import com.hardcode.gdbms.engine.values.Value;

import com.iver.cit.gvsig.fmap.DriverException;

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

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

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

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

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

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

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

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

	 */

	public int doAddRow(IRow feat, int sourceType) throws DriverIOException,

			IOException {

		int calculatedIndex = super.doAddRow(feat, sourceType);

		// Actualiza el ?ndice espacial

		IGeometry g = ((IFeature) feat).getGeometry();

		return calculatedIndex;

	}

	/**

	 * Se desmarca como invalidada en el fichero de expansion o como eliminada

	 * en el fichero original

	 * @throws IOException DOCUMENT ME!

	 */

	public synchronized IGeometry getShape(int index) throws IOException {

		Point2D.Double p = new Point2D.Double();

		int numParts;

		int numPoints;

		switch (type) {

			case (SHP.POINT2D):

				p = readPoint(bb);

			case (SHP.POLYLINE2D):

				bb.position(bb.position() + 32);

				numParts = bb.getInt();

				numPoints = bb.getInt();

						elShape.lineTo(p.x, p.y);

					}

				}

			case (SHP.POLYGON2D):

				//	            	BoundingBox = readRectangle(bb);

						elShape.lineTo(p.x, p.y);

					}

				}

			case (SHP.POINT3D):

				double x = bb.getDouble();

				double y = bb.getDouble();

				double z = bb.getDouble();

			case (SHP.POLYLINE3D):

				bb.position(bb.position() + 32);

				numParts = bb.getInt();

				for (i = 0; i < numPoints; i++) {

					pZ[i] = bb.getDouble();

				}

			case (SHP.POLYGON3D):

			bb.position(bb.position() + 32);

			numParts = bb.getInt();

			for (i = 0; i < numPoints; i++) {

				poZ[i] = bb.getDouble();

			}

			case (SHP.MULTIPOINT2D):

				bb.position(bb.position() + 32);

				numPoints = bb.getInt();

					tempX[i] = bb.getDouble();

					tempY[i] = bb.getDouble();

				}

			case (SHP.MULTIPOINT3D):

				bb.position(bb.position() + 32);

				numPoints = bb.getInt();

				for (i = 0; i < numPoints; i++) {

					temZ[i] = bb.getDouble();

				}

		}

	}

	/**

		extent = new Rectangle2D.Double(myHeader.myXmin, myHeader.myYmin,

				myHeader.myXmax - myHeader.myXmin,

				myHeader.myYmax - myHeader.myYmin);

		type = myHeader.myShapeType;

		double x = myHeader.myXmin;

		double y = myHeader.myYmin;

		double w = myHeader.myXmax - myHeader.myXmin;

 */

public class FMultiPoint2D implements IGeometry {

	FPoint2D[] points = null;

	/**

	 * Crea un nuevo MultiPoint2D.

            theGeoms[i] = c;

        }

        MultiPoint geomCol = new GeometryFactory().createMultiPoint(theGeoms);

		return geomCol;

	}

	 * @see com.iver.cit.gvsig.fmap.core.IGeometry#getGeometryType()

	 */

	public int getGeometryType() {

	}

	/* (non-Javadoc)

		{

			aux[i] = (FPoint2D) points[i].cloneFShape();

		}

	}

	/* (non-Javadoc)

	public Shape getInternalShape() {

		return this;

	}

}

	public Point2D getPoint() {

		return point;

	}

	public void select(boolean b) {

	 select=b;

	}

	public boolean isSelected(){

		return select;

	}

}

	 * @return una de las constantes de FShape: POINT, LINE, POLIGON

	 */

	int getGeometryType();

	/**

	 * Clona la Geometr?a.

	 *

	 * @return Geometr?a clonada.

	public void transform(AffineTransform at);

	PathIterator getPathIterator(AffineTransform at, double flatness);

	/**

	 * Useful to have the real shape behind the scenes.

	 * May be uses to edit it knowing it it is a Circle, Ellipse, etc

 * Created on 12-may-2005

 *

 * 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

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

 */

    private AffineTransform affineTransform = null;

    private boolean generalize = false;

    private double maxDistance = 1;

    // cached iterators

    private LineIterator lineIterator = new LineIterator();

    private GeomCollectionIterator collIterator = new GeomCollectionIterator();

    private float xScale;

    private float yScale;

    private GeometryFactory geomFac;

    private MathTransform mathTransform;

    private static final AffineTransform IDENTITY = new AffineTransform();

	class PointHandler extends AbstractHandler {

		/**

		 * Crea un nuevo PointHandler.

		 *

		 * @return DOCUMENT ME!

		 */

			c.x+=x;

			c.y+=y;

			geometry.geometryChanged();

			geometry.geometryChanged();

		}

	}

    /**

     * Creates a new LiteShape object.

     *

     * @param generalize - set to true if the geometry need to be generalized

     *        during rendering

     * @param maxDistance - distance used in the generalization process

     */

    public FLiteShape(Geometry geom, AffineTransform at, MathTransform mathTransform, boolean generalize,

        double maxDistance) throws TransformException, FactoryException {

     * @param generalize - set to true if the geometry need to be generalized

     *        during rendering

     * @param maxDistance - distance used in the generalization process

     */

    public FLiteShape(Geometry geom, AffineTransform at, MathTransform mathTransform, boolean generalize) throws TransformException, FactoryException {

        if( geom!=null)

     * @param generalize - set to true if the geometry need to be generalized

     *        during rendering

     * @param maxDistance - distance used in the generalization process

     */

    public FLiteShape(Geometry geom, AffineTransform at, boolean generalize,

        double maxDistance){

        this(geom, at, generalize);

        this.maxDistance = maxDistance;

    }

    public FLiteShape(Geometry geom)

    {

        this(geom, null, false);

     * @param generalize - set to true if the geometry need to be generalized

     *        during rendering

     * @param maxDistance - distance used in the generalization process

     */

    public FLiteShape(Geometry geom, AffineTransform at, boolean generalize){

        if( geom!=null)

                (affineTransform.getScaleY() * affineTransform.getScaleY())

                + (affineTransform.getShearY() * affineTransform.getShearY()));

    }

    private void transformGeometry(Geometry geometry) throws TransformException, FactoryException {

        if( mathTransform==null || mathTransform.isIdentity() ){

            if( !affineTransform.isIdentity() ){

                MathTransformFactory factory=FactoryFinder.getMathTransformFactory(null);

            factory.createConcatenatedTransform(mathTransform, factory.createAffineTransform(new GeneralMatrix(affineTransform)));

            affineTransform=IDENTITY;

        }

        if( mathTransform==null || mathTransform.isIdentity() )

            return;

        CoordinateSequenceTransformer transformer=new InPlaceCoordinateSequenceTransformer();

        if (geometry instanceof GeometryCollection) {

            GeometryCollection collection=(GeometryCollection)geometry;

            }

        }else if (geometry instanceof Point) {

            transformer.transform(((Point)geometry).getCoordinateSequence(), mathTransform);

            Polygon polygon=(Polygon) geometry;

            transformGeometry(polygon.getExteriorRing());

            for (int i = 0; i < polygon.getNumInteriorRing(); i++) {

            }

        } else if (geometry instanceof LineString) {

            transformer.transform(((LineString)geometry).getCoordinateSequence(), mathTransform);

    }

    private GeometryFactory getGeometryFactory() {

     * object instead of creating it again and again during rendering

     *

     * @param g

     */

    public void setGeometry(Geometry g) throws TransformException, FactoryException {

        if( g!=null){

        } catch (FactoryException e) {

            // TODO Auto-generated catch block

            e.printStackTrace();

        xScale = (float) Math.sqrt(

            (affineTransform.getScaleX() * affineTransform.getScaleX())

            + (affineTransform.getShearX() * affineTransform.getShearX()));

        yScale = (float) Math.sqrt(

            (affineTransform.getScaleY() * affineTransform.getScaleY())

            + (affineTransform.getShearY() * affineTransform.getShearY()));

    }

    /**

     * Tests if the interior of the <code>Shape</code> entirely contains the

     * specified <code>Rectangle2D</code>. This method might conservatively

     * return <code>false</code> when:

     * <ul>

     * <li>

     * the <code>intersect</code> method returns <code>true</code> and

     * expensive.

     * </li>

     * </ul>

     * This means that this method might return <code>false</code> even though

     * the <code>Shape</code> contains the <code>Rectangle2D</code>. The

     * <code>Area</code> class can be used to perform more accurate

     * rectangular area must lie within the <code>Shape</code> for the entire

     * rectanglar area to be considered contained within the

     * <code>Shape</code>.

     * <p>

     * This method might conservatively return <code>false</code> when:

     * <ul>

     * <li>

     * the <code>intersect</code> method returns <code>true</code> and

     * entirely contains the rectangular area are prohibitively expensive.

     * </li>

     * </ul>

     * This means that this method might return <code>false</code> even though

     * the <code>Shape</code> contains the rectangular area. The

     * <code>Area</code> class can be used to perform more accurate

     * boundary and provides access to the geometry of the <code>Shape</code>

     * outline.  If an optional {@link AffineTransform} is specified, the

     * coordinates returned in the iteration are transformed accordingly.

     * <p>

     * Each call to this method returns a fresh <code>PathIterator</code>

     * object that traverses the geometry of the <code>Shape</code> object

     * independently from any other <code>PathIterator</code> objects in use

     * at the same time.

     * </p>

     * <p>

     * It is recommended, but not guaranteed, that objects implementing the

     * <code>Shape</code> interface isolate iterations that are in process

     * from any changes that might occur to the original object's geometry

     * during such iterations.

     * </p>

     * <p>

     * Before using a particular implementation of the <code>Shape</code>

     * interface in more than one thread simultaneously, refer to its

            pi = new PointIterator((Point) geometry, combined);

        }

            pi = new PolygonIterator((Polygon) geometry, combined, generalize,

                    maxDistance);

            if(combined == affineTransform)

                lineIterator.init((LineString) geometry, combined, generalize,

                        (float) maxDistance, xScale, yScale);

                lineIterator.init((LineString) geometry, combined, generalize,

                        (float) maxDistance);

            pi = lineIterator;

     * Returns an iterator object that iterates along the <code>Shape</code>

     * boundary and provides access to a flattened view of the

     * <code>Shape</code> outline geometry.

     * <p>

     * Only SEG_MOVETO, SEG_LINETO, and SEG_CLOSE point types are returned by

     * the iterator.

     * </p>

     * <p>

     * If an optional <code>AffineTransform</code> is specified, the

     * coordinates returned in the iteration are transformed accordingly.

     * </p>

     * <p>

     * The amount of subdivision of the curved segments is controlled by the

     * <code>flatness</code> parameter, which specifies the maximum distance

     * flattening parameters to be treated as larger values.  This limit, if

     * there is one, is defined by the particular implementation that is used.

     * </p>

     * <p>

     * Each call to this method returns a fresh <code>PathIterator</code>

     * object that traverses the <code>Shape</code> object geometry

     * independently from any other <code>PathIterator</code> objects in use

     * at the same time.

     * </p>

     * <p>

     * It is recommended, but not guaranteed, that objects implementing the

     * <code>Shape</code> interface isolate iterations that are in process

     * from any changes that might occur to the original object's geometry

     * during such iterations.

     * </p>

     * <p>

     * Before using a particular implementation of this interface in more than

     * one thread simultaneously, refer to its documentation to verify that it

     * Tests if the interior of the <code>Shape</code> intersects the interior

     * of a specified <code>Rectangle2D</code>. This method might

     * conservatively return <code>true</code> when:

     * <ul>

     * <li>

     * there is a high probability that the <code>Rectangle2D</code> and the

     * prohibitively expensive.

     * </li>

     * </ul>

     * This means that this method might return <code>true</code> even though

     * the <code>Rectangle2D</code> does not intersect the <code>Shape</code>.

     *

     * of a specified rectangular area. The rectangular area is considered to

     * intersect the <code>Shape</code> if any point is contained in both the

     * interior of the <code>Shape</code> and the specified rectangular area.

     * <p>

     * This method might conservatively return <code>true</code> when:

     * <ul>

     * <li>

     * there is a high probability that the rectangular area and the

     * prohibitively expensive.

     * </li>

     * </ul>

     * This means that this method might return <code>true</code> even though

     * the rectangular area does not intersect the <code>Shape</code>. The

     * {@link java.awt.geom.Area Area} class can be used to perform more

        return geometry.getFactory().createPolygon(lr, null);

    }

    /**

     * Returns the affine transform for this lite shape

     * @return

        if (geometry instanceof MultiLineString)

            type = FShape.LINE;

        return type;

    }

            pointCoords[i] = pt.getX();

            pointCoords[i+1] = pt.getY();

        } */

    }

	public Handler[] getStretchingHandlers() {

import java.awt.geom.Rectangle2D;

import java.io.IOException;

import java.util.ArrayList;

import org.cresques.cts.ICoordTrans;

import org.geotools.data.postgis.attributeio.WKBEncoder;

 */

public class FGeometryCollection implements IGeometry {

	private ArrayList geometries = new ArrayList();

	/**

	 * Crea un nuevo FGeometryCollection.

	 *

	 */

	public boolean intersects(Rectangle2D r) {

	    boolean resul = false;

		}

		return resul;

	}

		return ret;

		*/

	}

	/* (non-Javadoc)

	 * @see com.iver.cit.gvsig.fmap.core.IGeometry#draw(java.awt.Graphics2D, com.iver.cit.gvsig.fmap.ViewPort, com.iver.cit.gvsig.fmap.core.v02.FSymbol)

	 */

	public void draw(Graphics2D g, ViewPort vp, FSymbol symbol) {

	}

	/* (non-Javadoc)

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

			newGeometries[i] = ((IGeometry)geometries.get(i)).cloneGeometry();

	}

	/* (non-Javadoc)

            theGeoms[i] = ((IGeometry)geometries.get(i)).toJTSGeometry();

        }

        GeometryCollection geomCol = new GeometryFactory().createGeometryCollection(theGeoms);

		return geomCol;

	}

     * @see com.iver.cit.gvsig.fmap.core.IGeometry#drawInts(java.awt.Graphics2D, com.iver.cit.gvsig.fmap.ViewPort, com.iver.cit.gvsig.fmap.core.v02.FSymbol)

     */

    public void drawInts(Graphics2D g, ViewPort vp, FSymbol symbol) {

    }

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

			Handler[] handAux=((IGeometry)geometries.get(i)).getHandlers(type);

			for (int j=0;j<handAux.length;j++){

			}

		}

		return (Handler[])handlers.toArray(new Handler[0]);

	}

	public boolean intersects(double x, double y, double w, double h) {

		}

	}

	public Rectangle getBounds() {

	public Shape getInternalShape() {

		return this;

	}

}

 * @author Vicente Caballero Navarro

 */

public class FPolygon2D extends FPolyline2D {

	/**

	 * Crea un nuevo Polygon2D.

	 *

	 * @see com.iver.cit.gvsig.fmap.core.FShape#getShapeType()

	 */

	public int getShapeType() {

		return FShape.POLYGON;

	}

	/**

	 * Clona FPolygon2D.

	 *

	/* public void draw(Graphics2D g, ViewPort vp, Style2D symbol) {

	   gp.transform(vp.getAffineTransform());

	       g.setPaint(Color.red);

	       g.fill(gp);

	       g.setPaint(Color.black);

import java.awt.geom.AffineTransform;

import java.awt.geom.Arc2D;

import java.awt.geom.Point2D;

import java.awt.geom.Rectangle2D;

import java.util.ArrayList;

import com.iver.cit.gvsig.fmap.edition.UtilFunctions;

*

* @author Vicente Caballero Navarro

*/

	private Point2D init;

	private Point2D end;

	private double ydist;

			AffineTransform mT = AffineTransform.getRotateInstance(angle, init.getX(), init.getY());

			gp = new GeneralPathX(arc);

			gp.transform(mT);

	}

	/* (non-Javadoc)

	 * @see com.iver.cit.gvsig.fmap.core.FPolyline2D#intersects(java.awt.geom.Rectangle2D)

	 */

		// TODO Auto-generated method stub

		return null;

	}

}

 *

 * @author Vicente Caballero Navarro

 */

	private Point2D center;

	private double radio;

 * @author FJP

 */

public class FGeometry implements IGeometry3D {

    /* (non-Javadoc)

     * @see com.iver.cit.gvsig.fmap.core.IGeometry#drawInts(java.awt.Graphics2D, com.iver.cit.gvsig.fmap.ViewPort, com.iver.cit.gvsig.fmap.core.v02.FSymbol)

        FGraphicUtilities.DrawShape(g, vp.getAffineTransform(), decimatedShape, symbol);

    }

    /* (non-Javadoc)

     * @see com.iver.cit.gvsig.fmap.core.IGeometry#fastIntersects(double, double, double, double)

     */

        return WKBEncoder.encodeGeometry(toJTSGeometry());

    }

    /**