| gvSIG desktop 1

/*

 * Created on 02-mar-2004

 *

 * To change the template for this generated file go to

 * Window>Preferences>Java>Code Generation>Code and Comments

 */

package com.iver.cit.gvsig.fmap.core.v02;

/**

 * DOCUMENT ME!

 *

 * @author vcn To change the template for this generated type comment go to

 *         Window>Preferences>Java>Code Generation>Code and

 *         Comments

 */

public class FConstant {

	/**

     * Nombre de las unidades de medida, utilizadas.

     */

    public static String[] NAMES = null;

	public final static int SHAPE_TYPE_NULL = 0;

	public final static int SHAPE_TYPE_POINT = 1;

	public final static int SHAPE_TYPE_POLYLINE = 3;

	public final static int SHAPE_TYPE_POLYGON = 5;

	public final static int SHAPE_TYPE_MULTIPOINT = 8;

	public final static int SHAPE_TYPE_POINTZ = 11;

	public final static int SHAPE_TYPE_POLYLINEZ = 13;

	public final static int SHAPE_TYPE_POLYGONZ = 15;

	public final static int SHAPE_TYPE_MULTIPOINTZ = 18;

	public final static int SHAPE_TYPE_POINTM = 21;

	public final static int SHAPE_TYPE_POLYLINEM = 23;

	public final static int SHAPE_TYPE_POLYGONM = 25;

	public final static int SHAPE_TYPE_MULTIPOINTM = 28;

	public final static int LAYER_TYPE_DGN = 1;

	public final static int LAYER_TYPE_DWG = 2;

	public final static int LAYER_TYPE_DXF = 3;

	public final static int LAYER_TYPE_JPEG2000 = 4;

	public final static int LAYER_TYPE_SHP = 5;

	public final static int LAYER_TYPE_WMS = 6;

	public final static int LEGEND_TYPE_BREAK = 3;

	public final static int LEGEND_TYPE_DEFAULT = 1;

	public final static int LEGEND_TYPE_VALUE = 2;

	public final static int SYMBOL_TYPE_DEFAULT = 5;

	public final static int SYMBOL_TYPE_POINT = 1;

	public final static int SYMBOL_TYPE_LINE = 3;

	public final static int SYMBOL_TYPE_FILL = 5;

	public final static int SYMBOL_TYPE_TEXT = 7;

	public final static int SYMBOL_TYPE_ICON = 9;

	public final static int SYMBOL_TYPE_POINTZ = 11;

	public final static int SYMBOL_TYPE_MULTIPOINT = 8;

	public final static int SYMBOL_STYLE_POINTZ = 0;

	public final static int SYMBOL_TYPE_POLYLINEZ = 13;

	public final static int SYMBOL_TYPE_POLYGONZ = 15;

	// Para s?mbolos de tipo pol?gono.

	public final static int SYMBOL_STYLE_FILL_SOLID = 1;

	public final static int SYMBOL_STYLE_FILL_TRANSPARENT = 2;

	public final static int SYMBOL_STYLE_FILL_HORIZONTAL = 3;

	public final static int SYMBOL_STYLE_FILL_VERTICAL = 4;

	public final static int SYMBOL_STYLE_FILL_CROSS = 5;

	public final static int SYMBOL_STYLE_FILL_UPWARD_DIAGONAL = 6;

	public final static int SYMBOL_STYLE_FILL_DOWNWARD_DIAGONAL = 7;

	public final static int SYMBOL_STYLE_FILL_CROSS_DIAGONAL = 8;

	public final static int SYMBOL_STYLE_FILL_GRAYFILL = 9;

	public final static int SYMBOL_STYLE_FILL_LIGHTGRAYFILL = 10;

	public final static int SYMBOL_STYLE_FILL_DARKGRAYFILL = 11;

	//	Para s?mbolos de tipo Punto

	public final static int SYMBOL_STYLE_MARKER_CIRCLE = 30;

	public final static int SYMBOL_STYLE_MARKER_SQUARE = 31;

	public final static int SYMBOL_STYLE_MARKER_TRIANGLE = 32;

	public final static int SYMBOL_STYLE_MARKER_CROSS = 33;

	public final static int SYMBOL_STYLE_MARKER_TRUETYPE = 34;

	public final static int SYMBOL_STYLE_MARKER_IMAGEN = 35;		      

	// Para s?mbolos de l?neas

	public final static int SYMBOL_STYLE_LINE_SOLID = 60;

	public final static int SYMBOL_STYLE_LINE_DASH = 61;

	public final static int SYMBOL_STYLE_LINE_DOT = 62;

	public final static int SYMBOL_STYLE_LINE_DASHDOT = 63;

	public final static int SYMBOL_STYLE_LINE_DASHDOTDOT = 64;

	public final static int SYMBOL_STYLE_LINE_RAIL = 65;

	public final static int SYMBOL_STYLE_LINE_ARROW = 66;

	// Para s?mbolos de tipo texto

	public final static int SYMBOL_STYLE_TEXT_NORMAL = 90;

	public final static int SYMBOL_STYLE_TEXT_CURSIVE = 91;

	public final static int SYMBOL_STYLE_TEXT_BOLD = 92;

	public final static int SYMBOL_STYLE_TEXT_BOLDCURSIVE = 93;

	static{

	new FConstant();	

	}

	public FConstant(){

		if (NAMES == null) {

    		int i=0;

    		NAMES = new String[8];

    		NAMES[i++] = "Kilometros";

    		NAMES[i++] = "Metros";

    		NAMES[i++] = "Centimetros";

    		NAMES[i++] = "Milimetros";

    		NAMES[i++] = "Millas";

    		NAMES[i++] = "Yardas";

    		NAMES[i++] = "Pies";

    		NAMES[i++] = "Pulgadas";

    	}

	}

}

/*

 * Created on 28-abr-2004

 *

 * To change the template for this generated file go to

 * Window>Preferences>Java>Code Generation>Code and Comments

 */

package com.iver.cit.gvsig.fmap.core.v02;

import java.awt.Font;

import java.awt.FontMetrics;

import java.awt.Graphics2D;

import java.awt.Rectangle;

import java.awt.geom.AffineTransform;

import java.awt.geom.Point2D;

import org.apache.batik.ext.awt.geom.PathLength;

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

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

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

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

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

import com.vividsolutions.jts.geom.Geometry;

import com.vividsolutions.jts.geom.Point;

/**

 * DOCUMENT ME!

 *

 * @author fjp To change the template for this generated type comment go to

 *         Window>Preferences>Java>Code Generation>Code and

 *         Comments

 */

public class FGraphicUtilities {

    /**

     * DOCUMENT ME!

     *

     * @param g2 DOCUMENT ME!

     * @param mT2 DOCUMENT ME!

     * @param r DOCUMENT ME!

     * @param symbol DOCUMENT ME!

     */

    public static void DrawSymbol(Graphics2D g2, AffineTransform mT2,

        Rectangle r, FSymbol symbol) {

        FShape shp;

        AffineTransform mT = new AffineTransform();

        mT.setToIdentity();

        // g2.clearRect(r.x, r.y, r.width, r.height);

        // System.out.println("r = " + r.toString() + " Color preview:" + m_FSymbol.m_Color.toString());

        // System.out.println("symbol.m_symbolType= "+symbol.m_symbolType);

        switch (symbol.m_symbolType) {

            case FConstant.SYMBOL_TYPE_MULTIPOINT:

                shp = new FPoint2D(r.x + (r.width / 2),

                        r.y + (r.height / 2));

                //  Para no tener que clonarlo si viene en unidades de mapa

                boolean bAux22 = symbol.m_bUseSize;

                int alturaMetros2 = symbol.m_Size; // Nota: Cambiar m_Size a float

                if (symbol.m_bUseSize) {

                    symbol.m_Size = 8; // tama?o fijo

                    symbol.m_bUseSize = false;

                }

				//FShape auxshp=new FShape(shp.multipoint.getPoint(0));

                FGraphicUtilities.DrawShape(g2, mT, shp, symbol);

                if (bAux22) {

                    symbol.m_Size = alturaMetros2;

                    symbol.m_bUseSize = bAux22;

                }

                if (symbol.m_Font != null) {

                    // Para no tener que clonarlo si viene en unidades de mapa

                    boolean bAux = symbol.m_bUseFontSize;

                    symbol.m_bUseFontSize = false;

                    FGraphicUtilities.DrawLabel(g2, mT, shp, symbol,

                        new FLabel("Abcd"));

                    symbol.m_bUseFontSize = bAux;

                }

                break;

            case FConstant.SYMBOL_TYPE_POINT:

            case FConstant.SYMBOL_TYPE_POINTZ:

                shp = new FPoint2D(r.x + (r.width / 2),

                        r.y + (r.height / 2));

                //  Para no tener que clonarlo si viene en unidades de mapa

                boolean bAux2 = symbol.m_bUseSize;

                int alturaMetros = symbol.m_Size; // Nota: Cambiar m_Size a float

                if (symbol.m_bUseSize) {

                    symbol.m_Size = 8; // tama?o fijo

                    symbol.m_bUseSize = false;

                }

                FGraphicUtilities.DrawShape(g2, mT, shp, symbol);

                if (bAux2) {

                    symbol.m_Size = alturaMetros;

                    symbol.m_bUseSize = bAux2;

                }

                if (symbol.m_Font != null) {

                    // Para no tener que clonarlo si viene en unidades de mapa

                    boolean bAux = symbol.m_bUseFontSize;

                    symbol.m_bUseFontSize = false;

                    FGraphicUtilities.DrawLabel(g2, mT, shp, symbol,

                        new FLabel("Abcd"));

                    symbol.m_bUseFontSize = bAux;

                }

                break;

            case FConstant.SYMBOL_TYPE_LINE:

            case FConstant.SHAPE_TYPE_POLYLINEZ:

                Rectangle rect = mT2.createTransformedShape(r).getBounds();

                GeneralPathX line = new GeneralPathX();

                line.moveTo(rect.x, rect.y + (rect.height / 2));

                // line.lineTo(rect.x + rect.width/3, rect.y + rect.height);								

                // line.lineTo(rect.x + 2*rect.width/3, rect.y);				

                // line.lineTo(rect.x + rect.width, rect.y + rect.height/2);

                line.curveTo(rect.x + (rect.width / 3),

                    rect.y + (2 * rect.height),

                    rect.x + ((2 * rect.width) / 3), rect.y - rect.height,

                    rect.x + rect.width, rect.y + (rect.height / 2));

                shp = new FPolyline2D(line);

                FGraphicUtilities.DrawShape(g2, mT, shp, symbol);

                break;

            case FConstant.SYMBOL_TYPE_FILL:

            case FConstant.SHAPE_TYPE_POLYGONZ:

                GeneralPathX rectAux = new GeneralPathX(r);

                rectAux.transform(mT2);

                shp = new FPolygon2D( rectAux);

                // System.out.println("rect = "+rectAux.getBounds());

                FGraphicUtilities.DrawShape(g2, mT, shp, symbol);

                break;

        }

    }

    /**

     * DOCUMENT ME!

     *

     * @param g2 DOCUMENT ME!

     * @param mT DOCUMENT ME!

     * @param shp DOCUMENT ME!

     * @param theSymbol DOCUMENT ME!

     */

    public static void DrawShape(Graphics2D g2, AffineTransform mT, FShape shp,

        FSymbol theSymbol) {

        // Hacemos la transformaci?n del shape aqu? dentro... por ahora.

        if (shp == null) {

            return;

        }

        g2.setColor(theSymbol.m_Color);

        switch (shp.getShapeType()) {

            case FShape.POINT: //Tipo punto

                drawSymbolPoint(g2, mT, (FPoint2D) shp, theSymbol);

                break;

            case FShape.LINE:

                // Shape theShp = mT.createTransformedShape(shp.m_Polyline);

                // g2.setColor(theSymbol.m_Color);

                if (theSymbol.m_Stroke != null) {

                    g2.setStroke(theSymbol.m_Stroke);

                }

                g2.draw(shp);

                break;

            case FShape.POLYGON:

                g2.setPaint(theSymbol.m_Fill);

                if (theSymbol.m_Color != null) {

                    g2.fill(shp);

                }

                if (theSymbol.m_useOutline) {

                    g2.setColor(theSymbol.m_outlineColor);

                    if (theSymbol.m_Stroke != null) {

                        g2.setStroke(theSymbol.m_Stroke);

                    }

                    g2.draw(shp);

                }

                break;

        }

    }

    public static void DrawLabel(Graphics2D g2, AffineTransform mT, FShape shp,

        FSymbol theSymbol, FLabel theLabel) {

        float angle;

        float x;

        float y;

        Point2D pAux = null;

        // USAR TEXTLAYOUT SI QUEREMOS PERMITIR SELECCIONAR UN TEXTO

        // Y/O EDITARLO "IN SITU"

        /* if (m_labelValues[numReg].length() > 0)

           {

                   TextLayout layout = new TextLayout(m_labelValues[numReg], font, frc);

                   layout.draw(g2, x, y);

           } */

        if (shp == null) {

            return;

        }

        // Las etiquetas que pongamos a nulo ser? porque no la queremos dibujar.

        // ?til para cuando queramos eliminar duplicados.

        if (theLabel.getString() == null) {

            return;

        }

        FontMetrics metrics = g2.getFontMetrics();

        int width = metrics.stringWidth(theLabel.getString());

        int height = metrics.getMaxAscent();

        // int height = metrics.getHeight();

        g2.setFont(theSymbol.m_Font);

        g2.setColor(theSymbol.m_FontColor);

        // Aqu? hay que mirar m_Size y m_useSize...

        if (theSymbol.m_bUseFontSize) {

            // Suponemos que m_Size viene en coordenadas de mundo real

            // Esto habr? que cambiarlo. Probablemente usar Style2d de geotools en lugar

            // de FSymbol.

            // CAMBIO: La altura del texto la miramos en FLabel

            // float alturaPixels = (float) (theSymbol.m_FontSize * mT.getScaleX());

            float alturaPixels = (float) (theLabel.getHeight() * mT.getScaleX());

            /* System.out.println("m_bUseSize = " + theSymbol.m_bUseSize +

               " Escala: " + mT.getScaleX() + " alturaPixels = " + alturaPixels); */

            if (alturaPixels < 3) {

                return; // No leemos nada

            }

            Font nuevaFuente = theSymbol.m_Font.deriveFont(alturaPixels);

            g2.setFont(nuevaFuente);

            width = g2.getFontMetrics().stringWidth(theLabel.getString());

        }

        switch (shp.getShapeType()) {

            case FShape.POINT: //Tipo punto

            	pAux = new Point2D.Double(((FPoint2D)shp).getX(), ((FPoint2D)shp).getY());

                pAux = mT.transform(pAux, null);

                break;

            case FShape.LINE:

                // 

                if (theLabel.getOrig() == null) // Calculamos el punto y la orientaci?n solo la primera vez

                 {

                    PathLength pathLen = new PathLength(shp);

                    // if (pathLen.lengthOfPath() < width / mT.getScaleX()) return;

                    float midDistance = pathLen.lengthOfPath() / 2;

                    pAux = pathLen.pointAtLength(midDistance);

                    angle = pathLen.angleAtLength(midDistance);

                    if (angle < 0) {

                        angle = angle + (float) (2 * Math.PI);

                    }

                    if ((angle > (Math.PI / 2)) &&

                            (angle < ((3 * Math.PI) / 2))) {

                        angle = angle - (float) Math.PI;

                    }

                    theLabel.setRotation(Math.toDegrees(angle));

                    theLabel.setOrig(pAux);

                }

                pAux = mT.transform(theLabel.getOrig(), null);

                // pAux = theLabel.getOrig();

                // GlyphVector theGlyphs = theSymbol.m_Font.createGlyphVector(g2.getFontRenderContext(), theLabel);

                // Shape txtShp = TextPathLayout.layoutGlyphVector(theGlyphs, shp.m_Polyline,TextPathLayout.ALIGN_MIDDLE);				

                // g2.draw(txtShp);

                // System.out.println("Pintando etiqueta " + theLabel );

                break;

            case FShape.POLYGON:

                if (theLabel.getOrig() == null) // Calculamos el punto solo la primera vez

                 {

                    Geometry geo = FConverter.java2d_to_jts(shp);

                    // System.out.println("Area de " + m_labelValues[numReg] + " = "

                    //   + geo.getArea());

                    //   System.out.println(geo.toText()); 

                    Point pJTS = geo.getInteriorPoint();

                    FShape pLabel = FConverter.jts_to_java2d(pJTS);

                    theLabel.setRotation(0);

                    theLabel.setOrig(new Point2D.Double(((FPoint2D)pLabel).getX(), ((FPoint2D)pLabel).getX()));

                }

                pAux = mT.transform(theLabel.getOrig(), null);

                break;

        }

        AffineTransform ant = g2.getTransform();

        x = (float) pAux.getX();

        y = (float) pAux.getY();

        AffineTransform Tx = (AffineTransform) ant.clone();

        Tx.translate(x, y); // S3: final translation

        Tx.rotate(Math.toRadians(-theLabel.getRotation())); // S2: rotate around anchor

        g2.setTransform(Tx);

        switch (theLabel.getJustification()) {

            case FLabel.LEFT_BOTTOM:

                g2.drawString(theLabel.getString(), 0, 0 - 3);

                break;

            case FLabel.LEFT_CENTER:

                g2.drawString(theLabel.getString(), 0, 0 - (height / 2));

                break;

            case FLabel.LEFT_TOP:

                g2.drawString(theLabel.getString(), 0, 0 - height);

                break;

            case FLabel.CENTER_BOTTOM:

                g2.drawString(theLabel.getString(), 0 - (width / 2), 0 - 3);

                break;

            case FLabel.CENTER_CENTER:

                g2.drawString(theLabel.getString(), 0 - (width / 2),

                    0 - (height / 2));

                break;

            case FLabel.CENTER_TOP:

                g2.drawString(theLabel.getString(), 0 - (width / 2), 0 -

                    height);

                break;

            case FLabel.RIGHT_BOTTOM:

                g2.drawString(theLabel.getString(), 0 - width, 0 - 3);

                break;

            case FLabel.RIGHT_CENTER:

                g2.drawString(theLabel.getString(), 0 - width, 0 -

                    (height / 2));

                break;

            case FLabel.RIGHT_TOP:

                g2.drawString(theLabel.getString(), 0 - width, 0 - height);

                break;

        }

        // Restauramos

        g2.setTransform(ant);

    }

    /**

     * DOCUMENT ME!

     *

     * @param g2 DOCUMENT ME!

     * @param mT DOCUMENT ME!

     * @param shp DOCUMENT ME!

     * @param theSymbol DOCUMENT ME!

     */

    private static void drawSymbolPoint(Graphics2D g2, AffineTransform mT, FPoint2D pAux, FSymbol theSymbol) {

        int x;

        int y;

        x = (int) pAux.getX();

        y = (int) pAux.getY();

		/*if (x==0){

			x=100;

		}

		if (y==0){

			y=100;

		}

		*/

        Rectangle rectAux = new Rectangle();

        // Aqu? hay que mirar m_Size y m_useSize...

        float radio_simbolo;

        radio_simbolo = theSymbol.m_Size / 2;

        if (theSymbol.m_bUseSize) {

            // Suponemos que m_Size viene en coordenadas de mundo real

            radio_simbolo = (float) (theSymbol.m_Size * mT.getScaleX());

            /* System.out.println("m_bUseSize = " + theSymbol.m_bUseSize +

               " Escala: " + mT.getScaleX() + " alturaPixels = " + alturaPixels); */

            // if (radio_simbolo < 1) return; // No dibujamos nada

            rectAux.setRect(x - radio_simbolo, y - radio_simbolo,

                radio_simbolo * 2, radio_simbolo * 2);

        } else {

            // m_Size viene en pixels

            rectAux.setRect(x - radio_simbolo, y - radio_simbolo,

                theSymbol.m_Size, theSymbol.m_Size);

        }

        // 	continue; //radioSimbolo_en_pixels = 3;

        if (theSymbol.m_Fill != null) {

            g2.setPaint(theSymbol.m_Fill);

        }

        if (theSymbol.m_Stroke != null) {

            g2.setStroke(theSymbol.m_Stroke);

        }

        if (radio_simbolo < 2) {

            g2.fillRect(rectAux.x, rectAux.y, rectAux.width, rectAux.height);

            return;

        }

        switch (theSymbol.m_Style) {

            case FConstant.SYMBOL_STYLE_MARKER_CIRCLE: // Circulito

                if (theSymbol.m_Color != null) {

                    g2.fillOval(rectAux.x, rectAux.y, rectAux.width,

                        rectAux.height);

                }

                if (theSymbol.m_useOutline) {

                    g2.setColor(theSymbol.m_outlineColor);

                    g2.drawOval(rectAux.x, rectAux.y, rectAux.width,

                        rectAux.height);

                }

                break;

            case FConstant.SYMBOL_STYLE_MARKER_SQUARE: // Cuadrado

                g2.fillRect(rectAux.x, rectAux.y, rectAux.width, rectAux.height);

                if (theSymbol.m_useOutline) {

                    g2.setColor(theSymbol.m_outlineColor);

                    g2.drawRect(rectAux.x, rectAux.y, rectAux.width,

                        rectAux.height);

                }

                break;

            case FConstant.SYMBOL_STYLE_MARKER_TRIANGLE: // Triangulo

                // y = r*sin30, x = r*cos30

                GeneralPathX genPath = new GeneralPathX();

                genPath.moveTo(x - (int) (radio_simbolo * 0.866),

                    y + (int) (radio_simbolo * 0.5));

                genPath.lineTo(x + (int) (radio_simbolo * 0.866),

                    y + (int) (radio_simbolo * 0.5));

                genPath.lineTo(x, y - (float) radio_simbolo);

                genPath.closePath();

                g2.fill(genPath);

                break;

            case FConstant.SYMBOL_STYLE_MARKER_CROSS: // Cruz

                GeneralPathX genPathCruz = new GeneralPathX();

                genPathCruz.moveTo(x, y - radio_simbolo);

                genPathCruz.lineTo(x, y + radio_simbolo);

                genPathCruz.moveTo(x - radio_simbolo, y);

                genPathCruz.lineTo(x + radio_simbolo, y);

                g2.draw(genPathCruz);

                break;

            case 34: // TrueType marker

            /* lf.lfHeight = -radioSimbolo_en_pixels;

               angulo = pSimbolo->m_Rotation;  // En radianes, de -pi a pi

               angulo = -180.0 * angulo / PI;

               lf.lfEscapement = (long) angulo*10;

               lf.lfOrientation = (long) angulo*10;

               fuente.CreateFontIndirect(&lf);

               pOldFont = pDC->SelectObject(&fuente);

               pDC->TextOut(pAPI.x, pAPI.y+radioSimbolo_en_pixels/2,elChar,1);

               pDC->SelectObject(pOldFont);

               fuente.DeleteObject();

               break; */

            case FConstant.SYMBOL_STYLE_MARKER_IMAGEN: // Icono

            {

            	if (theSymbol.m_Icon != null)

            	{

            		float w, h;

                    if (theSymbol.m_bUseSize) {

                        // Suponemos que m_Size viene en coordenadas de mundo real

                    	// Por ejemplo, nos valemos del ancho para fijar la escala

                        w = (float) (theSymbol.m_Size * mT.getScaleX());

                        h = theSymbol.m_Icon.getHeight(null) * w / theSymbol.m_Icon.getWidth(null);  

                        rectAux.setRect(x - w, y - h,

                            w * 2, h * 2);

                    } else {

                        // m_Size viene en pixels

                    	w = theSymbol.m_Size;

                        h = theSymbol.m_Icon.getHeight(null) * w / theSymbol.m_Icon.getWidth(null);                    	

                        rectAux.setRect(x - w, y - h, w, h);

                    }

            		g2.drawImage(theSymbol.m_Icon, rectAux.x, rectAux.y, rectAux.width, rectAux.height, null);

            	}

            	else

            	{

            		String strImg = "Image"; // Utilities.getMessage(FGraphicUtilities.class,"imagen"); 

                    FontMetrics metrics = g2.getFontMetrics();

                    int width = metrics.stringWidth(strImg);

                    int height = metrics.getMaxAscent();

            		g2.drawString(strImg, x - width/2, y -2 + height/2);

            	}

            	break;

            }

            /* DrawIconEx(pDC->m_hDC, pAPI.x-(pSimbolo->m_widthIco/2), pAPI.y-(pSimbolo->m_heightIco/2),

               pSimbolo->m_hIcon, pSimbolo->m_widthIco, pSimbolo->m_heightIco, 0 , NULL, DI_NORMAL);

               break; */

            case FConstant.SYMBOL_STYLE_POINTZ: // Circulito

                if (theSymbol.m_Color != null) {

                    g2.fillOval(rectAux.x, rectAux.y, rectAux.width,

                        rectAux.height);

                }

                if (theSymbol.m_useOutline) {

                    g2.setColor(theSymbol.m_outlineColor);

                    g2.drawOval(rectAux.x, rectAux.y, rectAux.width,

                        rectAux.height);

                }

                break;

        } // del switch estilo

    }

}

/*

 * Created on 13-jul-2004

 *

 * TODO To change the template for this generated file go to

 * Window - Preferences - Java - Code Generation - Code and Comments

 */

package com.iver.cit.gvsig.fmap.core.v02;

import java.awt.geom.Point2D;

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

import com.iver.utiles.XMLEntity;

/**

 * @author FJP

 *

 * Se utiliza para etiquetar. Las capas vectoriales tienen un arrayList (m_labels) de FLabel, un

 * FLabel por cada registro.

 */

public class FLabel implements Cloneable {

	public final static byte LEFT_TOP = 0;

	public final static byte LEFT_CENTER = 1;

	public final static byte LEFT_BOTTOM = 2;

	public final static byte CENTER_TOP = 6;

	public final static byte CENTER_CENTER = 7;

	public final static byte CENTER_BOTTOM = 8;

	public final static byte RIGHT_TOP = 12;

	public final static byte RIGHT_CENTER = 13;

	public final static byte RIGHT_BOTTOM = 14;

	private String m_Str = null;

	private Point2D m_Orig = null;

	private double m_Height;

	/**

	 * <code>m_rotation</code> en grados, NO en radianes. Se convierte en radianes al dibujar.

	 */

	private double m_rotation;

	/**

	 * Valores posibles para <code>m_Justification</code>:

	 * Left/Top = 0				Center/Top = 6				Right/Top = 12

	 * Left/Center = 1			Center/Center = 7			Right/Center = 13

	 * Left/Bottom = 2			Center/Bottom = 8			Right/Bottom = 14

	 */

	private byte m_Justification = LEFT_BOTTOM; // Por defecto 

	FLabel()

	{

	}

	public FLabel(String str)

	{

		m_Str  = str;

	}

	public FLabel(String str, Point2D pOrig, double heightText, double rotation)

	{

		m_Str = str;

		m_Orig = pOrig;

		m_Height = heightText;

		m_rotation = rotation;

	}

	public void setFLabel(FLabel label)

	{

		m_Str = label.m_Str;

		m_Orig = label.m_Orig;

		m_Height = label.m_Height;

		m_rotation = label.m_rotation;

	}

	public Object clone()

	{

		return new FLabel(m_Str,m_Orig, m_Height, m_rotation);

	}

	/**

	 * @return Returns the m_Height.

	 */

	public double getHeight() {

		return m_Height;

	}

	/**

	 * @return Returns the m_Orig.

	 */

	public Point2D getOrig() {

		return m_Orig;

	}

	/**

	 * @return Returns the m_rotation.

	 */

	public double getRotation() {

		return m_rotation;

	}

	/**

	 * @return Returns the m_Str.

	 */

	public String getString() {

		return m_Str;

	}

	/**

	 * @param height The m_Height to set.

	 */

	public void setHeight(double height) {

		m_Height = height;

	}

	/**

	 * @param orig The m_Orig to set.

	 */

	public void setOrig(Point2D orig) {

		m_Orig = orig;

	}

	/**

	 * @param m_rotation The m_rotation to set.

	 */

	public void setRotation(double m_rotation) {

		this.m_rotation = m_rotation;

	}

	/**

	 * @param str The m_Str to set.

	 */

	public void setString(String str) {

		m_Str = str;

	}

	/**

	 * Valores posibles para <code>m_Justification</code>:

	 * Left/Top = 0				Center/Top = 6				Right/Top = 12

	 * Left/Center = 1			Center/Center = 7			Right/Center = 13

	 * Left/Bottom = 2			Center/Bottom = 8			Right/Bottom = 14

	 */

	public byte getJustification() {

		return m_Justification;

	}

	/**

	 * Valores posibles para <code>m_Justification</code>:

	 * Left/Top = 0				Center/Top = 6				Right/Top = 12

	 * Left/Center = 1			Center/Center = 7			Right/Center = 13

	 * Left/Bottom = 2			Center/Bottom = 8			Right/Bottom = 14

	 */

	public void setJustification(byte justification) {

		m_Justification = justification;

	}

	/**

		 * Devuelve un Objeto XMLEntity con la informaci?n los atributos necesarios

		 * para poder despu?s volver a crear el objeto original.

		 *

		 * @return XMLEntity.

		 */

		public XMLEntity getXMLEntity() {

			XMLEntity xml = new XMLEntity();

			xml.setName("flabel");

			xml.putProperty("m_Height", m_Height);

			xml.putProperty("m_Justification", (int)m_Justification);

			xml.putProperty("m_OrigX", m_Orig.getX());

			xml.putProperty("m_OrigY", m_Orig.getY());

			xml.putProperty("m_rotation", m_rotation);

			xml.putProperty("m_Str", m_Str);

			return xml;

		}

		/**

		 * Crea un Objeto de esta clase a partir de la informaci?n del XMLEntity.

		 *

		 * @param xml XMLEntity

		 *

		 * @return Objeto de esta clase.

		 */

		public static FLabel createFLabel(XMLEntity xml) {

			FLabel label = new FLabel();

			label.setHeight(xml.getDoubleProperty("m_Height"));

			label.setJustification((byte)xml.getIntProperty("m_Justification"));

			label.setOrig(new Point2D.Double(xml.getDoubleProperty("m_OrigX"),xml.getDoubleProperty("m_OrigY")));

			label.setString("m_Str");

			return label;

		}

}

/*

 * Created on 19-feb-2004

 *

 * To change the template for this generated file go to

 * Window>Preferences>Java>Code Generation>Code and Comments

 */

package com.iver.cit.gvsig.fmap.core.v02;

import java.awt.BasicStroke;

import java.awt.Color;

import java.awt.Font;

import java.awt.Image;

import java.awt.Paint;

import java.awt.Stroke;

import com.iver.utiles.StringUtilities;

import com.iver.utiles.XMLEntity;

/**

 * DOCUMENT ME!

 *

 * @author vcn To change the template for this generated type comment go to

 *         Window>Preferences>Java>Code Generation>Code and

 *         Comments

 */

public class FSymbol {

    public int m_symbolType;

    public int m_Style;

    public boolean m_useOutline;

    public Color m_Color;

    public Color m_outlineColor;

    public Font m_Font;

    public Color m_FontColor;

    public float m_FontSize;

    /**

     * Si <code>m_bUseFontSize</code> viene a true entonces m_FontSize viene en unidades de mapa (metros)

     */

    public boolean m_bUseFontSize; 

    /**

     * <code>m_bDrawShape</code> indica si queremos dibujar el shape de fondo. Es ?til

     * cuando est?s etiquetando y no quieres que se dibuje el s?mbolo que te sirve de

     * base para etiquetar.

     */

    public boolean m_bDrawShape = true;

    public int m_Size;

    public Image m_Icon;

    public int m_Rotation;

    public Paint m_Fill;

    public String m_LinePattern = "0"; // Solo para poder mostrarlo cuando vamos a seleccionar un s?mbolo

    									// En realidad lo podemos ver de BasicStroke, pero....

    									// ya veremos si luego lo quitamos.

    public Stroke m_Stroke;

    //private float m_stroke=0;

    // public int m_Transparency; // Ya la lleva dentro del Color

    public boolean m_bUseSize;	// Si est? a true, m_Size viene en coordenadas de mundo real.

    public int m_AlingVert;

    public int m_AlingHoriz;

    public String m_Descrip;

    public Color m_BackColor;

    public Paint m_BackFill;

	public FSymbol cloneSymbol()

	{

		FSymbol nS = new FSymbol();

		nS.m_symbolType = m_symbolType; 

		nS.m_Style = m_Style;

		nS.m_useOutline = m_useOutline;

		nS.m_Color = m_Color;

		nS.m_outlineColor = m_outlineColor;

		nS.m_Font = m_Font;

		nS.m_FontColor = m_FontColor;

		nS.m_FontSize = m_FontSize;

		nS.m_bUseFontSize = m_bUseFontSize;

		nS.m_bDrawShape = m_bDrawShape;

		nS.m_Size = m_Size;

		nS.m_Icon = m_Icon;

		nS.m_Rotation = m_Rotation;

		nS.m_Fill = m_Fill;

		nS.m_Stroke = m_Stroke;

		// nS.m_Transparency =m_Transparency ;

		nS.m_bUseSize = m_bUseSize;

		nS.m_AlingVert = m_AlingVert;

		nS.m_AlingHoriz = m_AlingHoriz;

		nS.m_Descrip = m_Descrip;

		nS.m_BackColor = m_BackColor;

		nS.m_BackFill = m_BackFill;

		nS.m_LinePattern = m_LinePattern;

		return nS;

	}

	public FSymbol()

	{

	}

	private void createSymbol(int tipoSymbol, Color c)

	{

		// Tipo de simbolo

		m_symbolType = tipoSymbol;

		// Ponemos un estilo por defecto

		m_useOutline = true;

		m_Color = c;

		m_Stroke = null;

		m_Fill = null;

		m_FontColor = Color.BLACK;

		m_Size = 0;

		switch (m_symbolType)

		{        

			case FConstant.SYMBOL_TYPE_POINT:

			case FConstant.SYMBOL_TYPE_POINTZ:

			case FConstant.SYMBOL_TYPE_MULTIPOINT:

				m_useOutline = false;

				m_Style = FConstant.SYMBOL_STYLE_MARKER_SQUARE;

				m_Size = 5; //pixels

				break;

			case FConstant.SYMBOL_TYPE_LINE:

			case FConstant.SYMBOL_TYPE_POLYLINEZ:

			case FConstant.SYMBOL_TYPE_POLYGONZ:

				m_Stroke = new BasicStroke();

				m_Style = FConstant.SYMBOL_STYLE_LINE_SOLID;

				break;

			case FConstant.SYMBOL_TYPE_FILL:

				m_Style = FConstant.SYMBOL_STYLE_FILL_SOLID;

				break;		

		}

		m_outlineColor = c.darker();

	}

    /**

     * Creates a new FSymbol object.

     *

     * @param tipoSymbol DOCUMENT ME!

     */

	public FSymbol(int tipoSymbol, Color c) {

		createSymbol(tipoSymbol,c);

	}

	public FSymbol(int tipoSymbol) {

			int numreg = (int) (Math.random() * 100);

			Color colorAleatorio = new Color(((numreg * numreg) + 100) % 255,

					(numreg + ((3 * numreg) + 100)) % 255, numreg % 255);

			createSymbol(tipoSymbol, colorAleatorio);

			// }

	}

    /**

     * DOCUMENT ME!

     */

    public void onChangeSymbol() {

    }

	/**

		 * @see com.iver.cit.gvsig.gui.layout.fframes.IFFrame#getXMLEntity()

		 */

		public XMLEntity getXMLEntity(){

			XMLEntity xml=new XMLEntity();

			xml.putProperty("m_symbolType",m_symbolType);

			xml.putProperty("m_Style",m_Style);

			xml.putProperty("m_useOutline",m_useOutline);

			if (m_Color!=null){

			xml.putProperty("m_Color",StringUtilities.color2String(m_Color));

			}

			if (m_outlineColor!=null){

			xml.putProperty("m_outlineColor",StringUtilities.color2String(m_outlineColor));

			}

			if (m_Font!=null){

			xml.putProperty("fontname",m_Font.getName());

			xml.putProperty("fontstyle",m_Font.getStyle());

			xml.putProperty("m_FontSize",m_FontSize);

			xml.putProperty("m_FontColor",StringUtilities.color2String(m_FontColor));

			}

			xml.putProperty("m_bUseFontSize",m_bUseFontSize);

			xml.putProperty("m_bDrawShape",m_bDrawShape);

			xml.putProperty("m_Size",m_Size);

			//xml.putProperty("m_Icon",m_Icon.);

			xml.putProperty("m_Rotation",m_Rotation);

			if (m_Fill instanceof Color){

				xml.putProperty("m_Fill",StringUtilities.color2String((Color)m_Fill));	

			}

			xml.putProperty("m_LinePattern",m_LinePattern);

			//Ancho del stroke en float

			if (m_Stroke!=null){

			xml.putProperty("m_stroke",((BasicStroke)m_Stroke).getLineWidth());

			}else{

				xml.putProperty("m_stroke",0f);

			}

			xml.putProperty("m_bUseSize",m_bUseSize);

			xml.putProperty("m_AlingVert",m_AlingVert);

			xml.putProperty("m_AlingHoriz",m_AlingHoriz);

			xml.putProperty("m_Descrip",m_Descrip);

			if (m_BackColor!=null){

			xml.putProperty("m_BackColor",StringUtilities.color2String(m_BackColor));

			}

			if (m_BackFill instanceof Color){

				xml.putProperty("m_BackFill",StringUtilities.color2String((Color)m_BackFill));	

			}

			return xml;

		}

	public static FSymbol createFSymbol(XMLEntity xml) {

			FSymbol symbol = new FSymbol();

		symbol.m_symbolType=xml.getIntProperty("m_symbolType");

		symbol.m_Style=	xml.getIntProperty("m_Style");

		symbol.m_useOutline=xml.getBooleanProperty("m_useOutline");

		if (xml.getStringProperty("m_Color")!=null){

		symbol.m_Color=StringUtilities.string2Color(xml.getStringProperty("m_Color"));

		}

		if (xml.getStringProperty("m_outlineColor")!=null){

		symbol.m_outlineColor=StringUtilities.string2Color(xml.getStringProperty("m_outlineColor"));

		}

		if (xml.getStringProperty("m_FontColor")!=null){

		symbol.m_Font=new Font(xml.getStringProperty("fontname"),xml.getIntProperty("fontstyle"),(int)xml.getFloatProperty("m_FontSize"));

		symbol.m_FontColor=StringUtilities.string2Color(xml.getStringProperty("m_FontColor"));

		symbol.m_FontSize=xml.getFloatProperty("m_FontSize");

		}

		symbol.m_bUseFontSize=xml.getBooleanProperty("m_bUseFontSize");

		symbol.m_bDrawShape=xml.getBooleanProperty("m_bDrawShape");

		symbol.m_Size=xml.getIntProperty("m_Size");

		//xml.putProperty("m_Icon",m_Icon.);

		symbol.m_Rotation=xml.getIntProperty("m_Rotation");

		if (xml.getStringProperty("m_Fill")!=null){

			symbol.m_Fill=StringUtilities.string2Color(xml.getStringProperty("m_Fill"));	

		}

		symbol.m_LinePattern=xml.getStringProperty("m_LinePattern");

		//Ancho del stroke en float

		symbol.m_Stroke=new BasicStroke(xml.getFloatProperty("m_stroke"));

		symbol.m_bUseSize=xml.getBooleanProperty("m_bUseSize");

		symbol.m_AlingVert=xml.getIntProperty("m_AlingVert");

		symbol.m_AlingHoriz=xml.getIntProperty("m_AlingHoriz");

		symbol.m_Descrip=xml.getStringProperty("m_Descrip");

		if (xml.getStringProperty("m_BackColor")!=null){

		symbol.m_BackColor=StringUtilities.string2Color(xml.getStringProperty("m_BackColor"));

		}

		if (xml.getStringProperty("m_BackFill")!=null){

			symbol.m_BackFill=StringUtilities.string2Color(xml.getStringProperty("m_BackFill"));	

		}

			return symbol;

		}

}

/*

 * Created on 08-jun-2004

 *

 * TODO To change the template for this generated file go to

 * Window - Preferences - Java - Code Generation - Code and Comments

 */

package com.iver.cit.gvsig.fmap.core.v02;

import java.awt.geom.NoninvertibleTransformException;

import java.awt.geom.PathIterator;

import java.awt.geom.Point2D;

import java.lang.reflect.Array;

import java.util.ArrayList;

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

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

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

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

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

import com.vividsolutions.jts.algorithm.CGAlgorithms;

import com.vividsolutions.jts.algorithm.RobustCGAlgorithms;

import com.vividsolutions.jts.geom.Coordinate;

import com.vividsolutions.jts.geom.CoordinateArrays;

import com.vividsolutions.jts.geom.Envelope;

import com.vividsolutions.jts.geom.Geometry;

import com.vividsolutions.jts.geom.GeometryCollection;

import com.vividsolutions.jts.geom.GeometryFactory;

import com.vividsolutions.jts.geom.LineString;

import com.vividsolutions.jts.geom.LinearRing;

import com.vividsolutions.jts.geom.MultiLineString;

import com.vividsolutions.jts.geom.MultiPolygon;

import com.vividsolutions.jts.geom.Point;

import com.vividsolutions.jts.geom.Polygon;

/**

 * @author fjp

 *

 * TODO To change the template for this generated type comment go to

 * Window - Preferences - Java - Code Generation - Code and Comments

 */

public class FConverter {

	/**

	 * ?QU? PODEMOS HACER CON LOS MULTIPOINT??? => DEBER?AMOS TRABAJAR CON UN ARRAY

	 * DE PUNTOS EN FShape.....Pensarlo bien.

	 * 

	 * 

	 */

	private final static GeometryFactory geomFactory = new GeometryFactory();

	protected static CGAlgorithms cga = new RobustCGAlgorithms();

    //returns true if testPoint is a point in the pointList list.

    static boolean pointInList(Coordinate testPoint, Coordinate[] pointList)

    {

        int t, numpoints;

        Coordinate  p;

        numpoints = Array.getLength( pointList) ;

        for (t=0;t<numpoints; t++)

        {

            p = pointList[t];

            if ( (testPoint.x == p.x) && (testPoint.y == p.y) &&

                    ((testPoint.z == p.z) || (!(testPoint.z == testPoint.z))  )  //nan test; x!=x iff x is nan

                    )

            {

                return true;

            }

        }

        return false;

    }

	/**

	 * Convierte un FShape a una Geometry del JTS. Para ello, utilizamos un 

	 * "flattened PathIterator". El flattened indica que las curvas las pasa a segmentos

	 * de l?nea recta AUTOMATICAMENTE!!!.

	 */

	 public static Geometry java2d_to_jts(FShape shp)

	 {

	 	double flatness = 0.8; // Por ejemplo. Cuanto m?s peque?o, m?s segmentos necesitar? la curva

	 							// Es la m?xima distancia que permitimos que el trazo aproximado

	 							// difiera del trazo real.

	 	Geometry geoJTS = null;

	 	Coordinate coord;

	 	Coordinate[] coords;

	 	ArrayList arrayCoords = null;

	 	ArrayList arrayLines;

	 	LineString lin;

	 	LinearRing linRing, linRingExt = null;

	 	int theType; 

	 	int numParts = 0;

//	 	Use this array to store segment coordinate data

	    double[] theData = new double[6]; 

	    PathIterator theIterator;

	 	switch (shp.getShapeType())

		{

	 		case FShape.POINT:

	 			FPoint2D p = (FPoint2D) shp;

	 			coord = new Coordinate(p.getX(), p.getY());

	 			geoJTS = new GeometryFactory().createPoint(coord);

	 			break;

	 		case FShape.LINE:	 				 			

	 			arrayLines = new ArrayList();

	 			theIterator = shp.getPathIterator(null); //, flatness);

		 		while(!theIterator.isDone()){

		 		    //while not done

		 		      theType = theIterator.currentSegment(theData);

		 		      //Populate a segment of the new

		 		      // GeneralPathX object.

		 		     //Process the current segment to populate a new

		 		      // segment of the new GeneralPathX object.

		 		      switch(theType){

		 		        case PathIterator.SEG_MOVETO :

		 		          // System.out.println("SEG_MOVETO");

		 		          if (arrayCoords == null)

		 		          {

		 		          		arrayCoords = new ArrayList();		

		 		          }

		 		          else

		 		          {

		 		          		lin = new GeometryFactory().createLineString(

		 		          				CoordinateArrays.toCoordinateArray(arrayCoords));

		 		          		arrayLines.add(lin);

		 		          		arrayCoords = new ArrayList();

		 		          }

		 		          numParts++;

		 		          arrayCoords.add(new Coordinate(theData[0], theData[1]));

		 		          break;

		 		        case PathIterator.SEG_LINETO :

		 		        	// System.out.println("SEG_LINETO");

		 		        	arrayCoords.add(new Coordinate(theData[0], theData[1]));

		 		          break;

		 		        case PathIterator.SEG_QUADTO :

		 		          System.out.println("Not supported here");     

		 		          break;

		 		        case PathIterator.SEG_CUBICTO :

		 		          System.out.println("Not supported here");

		 		          break;

		 		        case PathIterator.SEG_CLOSE :

		 		          System.out.println("SEG_CLOSE");

		 		          // A?adimos el primer punto para cerrar.

		 		          Coordinate firstCoord = (Coordinate) arrayCoords.get(0);

		 		          arrayCoords.add(new Coordinate(firstCoord.x, firstCoord.y));

		 		          break;

		 		      }//end switch

		 		      theIterator.next();

		 		    }//end while loop

	          		lin = new GeometryFactory().createLineString(

		          				CoordinateArrays.toCoordinateArray(arrayCoords));

		 			if (numParts > 1) // Generamos una MultiLineString

		 			{

		          		arrayLines.add(lin);

		 				geoJTS = new GeometryFactory().createMultiLineString(

		 							GeometryFactory.toLineStringArray(arrayLines));

		 			}

		 			else

		 			{

		 				geoJTS = lin;

		 			}

		 			break;

	 		case FShape.POLYGON:

	 			arrayLines = new ArrayList();

		        ArrayList shells = new ArrayList();

		        ArrayList holes = new ArrayList();

		        Coordinate[] points = null;

 				theIterator = shp.getPathIterator(null);//, flatness);

		 		while(!theIterator.isDone()){

		 		    //while not done

		 		      theType = theIterator.currentSegment(theData);

		 		      //Populate a segment of the new

		 		      // GeneralPathX object.

		 		     //Process the current segment to populate a new

		 		      // segment of the new GeneralPathX object.

		 		      switch(theType){

		 		        case PathIterator.SEG_MOVETO :

		 		          // System.out.println("SEG_MOVETO");

		 		          if (arrayCoords == null)

		 		          {

		 		          		arrayCoords = new ArrayList();		

		 		          }

		 		          else

		 		          {

		 		          		points = CoordinateArrays.toCoordinateArray(arrayCoords);

			 		            LinearRing ring = geomFactory.createLinearRing(points);

			 		            if(cga.isCCW(points)){

			 		                holes.add(ring);

			 		            }

			 		            else{

			 		                shells.add(ring);

			 		            }

		 		          	 	/* if (numParts == 1)

		 		          	 	{

		 		          	 		linRingExt = new GeometryFactory().createLinearRing(

		 		          				CoordinateArrays.toCoordinateArray(arrayCoords));

		 		          	 	}

		 		          	 	else

		 		          	 	{

		 		          	 		linRing = new GeometryFactory().createLinearRing(

			 		          				CoordinateArrays.toCoordinateArray(arrayCoords));		 		          	 		

		 		          	 		arrayLines.add(linRing);

		 		          	 	} */

		 		          		arrayCoords = new ArrayList();

		 		          }

		 		          numParts++;

		 		          arrayCoords.add(new Coordinate(theData[0], theData[1]));

		 		          break;

		 		        case PathIterator.SEG_LINETO :

		 		        	// System.out.println("SEG_LINETO");

		 		        	arrayCoords.add(new Coordinate(theData[0], theData[1]));

		 		          break;

		 		        case PathIterator.SEG_QUADTO :

		 		          System.out.println("SEG_QUADTO Not supported here");     

		 		          break;

		 		        case PathIterator.SEG_CUBICTO :

		 		          System.out.println("SEG_CUBICTO Not supported here");

		 		          break;

		 		        case PathIterator.SEG_CLOSE :

			 		          // A?adimos el primer punto para cerrar.

			 		          Coordinate firstCoord = (Coordinate) arrayCoords.get(0);

			 		          arrayCoords.add(new Coordinate(firstCoord.x, firstCoord.y));

		 		          break;

		 		      }//end switch

	 		          // System.out.println("theData[0] = " + theData[0] + " theData[1]=" + theData[1]);

		 		      theIterator.next();

	 		    }//end while loop

		 		// arrayCoords.add(arrayCoords.get(0));

          		points = CoordinateArrays.toCoordinateArray(arrayCoords);

	            LinearRing ring = geomFactory.createLinearRing(points);

	            if(cga.isCCW(points)){

	                holes.add(ring);

	            }

	            else{

	                shells.add(ring);

	            }

          		/* linRing = new GeometryFactory().createLinearRing(

	          				CoordinateArrays.toCoordinateArray(arrayCoords)); */

          		// System.out.println("NumParts = " + numParts);

                //now we have a list of all shells and all holes

                ArrayList holesForShells = new ArrayList(shells.size());

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

                    holesForShells.add(new ArrayList());

                }

                //find homes

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

                    LinearRing testRing = (LinearRing)holes.get(i);

                    LinearRing minShell = null;

                    Envelope minEnv = null;

                    Envelope testEnv = testRing.getEnvelopeInternal();

                    Coordinate testPt = testRing.getCoordinateN(0);

                    LinearRing tryRing;

                    for(int j=0;j<shells.size();j++){

                        tryRing = (LinearRing) shells.get(j);

                        Envelope tryEnv = tryRing.getEnvelopeInternal();

                        if (minShell != null) minEnv = minShell.getEnvelopeInternal();

                        boolean isContained = false;

                        Coordinate[] coordList = tryRing.getCoordinates() ;

                        if (tryEnv.contains(testEnv)

                                && (cga.isPointInRing(testPt,coordList ) || (pointInList(testPt, coordList)))

                           )

                            isContained = true;

                        // check if this new containing ring is smaller than the current minimum ring

                        if (isContained) {

                            if (minShell == null

                            || minEnv.contains(tryEnv)) {

                                minShell = tryRing;

                            }

                        }

                    }

                    if (minShell == null)

                    {

                        System.out.println("polygon found with a hole thats not inside a shell");

                    }

                    else

                    {

                      ((ArrayList)holesForShells.get(shells.indexOf(minShell))).add(testRing);

                    }

                }

                Polygon[] polygons = new Polygon[shells.size()];

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

                    polygons[i]=geomFactory.createPolygon((LinearRing)shells.get(i),(LinearRing[])((ArrayList)holesForShells.get(i)).toArray(new LinearRing[0]));

                }

                if(polygons.length==1){

                    return polygons[0];

                }

                holesForShells = null;

                shells = null;

                holes = null;

                //its a multi part

                geoJTS =  geomFactory.createMultiPolygon(polygons);

	 			/* if (numParts > 1) // Generamos un Polygon con agujeros

	 			{

	          		arrayLines.add(linRing);

	 				// geoJTS = new GeometryFactory().createPolygon(linRingExt, 

	 						// GeometryFactory.toLinearRingArray(arrayLines));

	          		geoJTS = new GeometryFactory().buildGeometry(arrayLines);

	          		// geoJTS = Polygonizer.class.

	 			}

	 			else

	 			{

	 				geoJTS = new GeometryFactory().createPolygon(linRing,null);

	 			} */

	 			break;

		}