Application: gvSIG desktop

/*

 * Created on 30-abr-2004

 *

 * @author "Luis W. Sevilla" <sevilla_lui@gva.es>

 */

package org.cresques.px.dxf;

import java.awt.Color;

import java.awt.Graphics2D;

import java.awt.geom.GeneralPath;

import java.awt.geom.Point2D;

import java.util.Iterator;

import java.util.Vector;

import org.cresques.cts.ICoordTrans;

import org.cresques.cts.IProjection;

import org.cresques.geo.ViewPortData;

import org.cresques.io.DxfGroup;

import org.cresques.px.Extent;

/**

 * Polilynea de autocad

 * jmorell: Implementaci?n extra de bulges necesaria para el piloto de CAD.

 * @author "Luis W. Sevilla" <sevilla_lui@gva.es>* @author administrador

 */

public class DxfPolyline extends DxfEntity {

        final static Color baseColor = new Color(69, 106, 121);

        Vector pts = null;

        Vector faces = null;

        GeneralPath gp = null;

        int flags = 0;

        boolean closed = false;

        boolean hasFaces = false;

        private Vector bulges;

        public DxfPolyline(IProjection proj, DxfLayer layer) {

                super(proj, layer);

                extent = new Extent();

                pts = new Vector();

                bulges = new Vector();

        }

        public void add(Point2D pt) {

                pts.add(pt);

                extent.add(pt);

        }

        /**

         * 050301, jmorell: Soluci?n provisional para implementar la lectura de polil?neas

         * con arcos.

         * @param pt

         */

        public void addBulge(Double bulge) {

                bulges.add(bulge);

        }

        public void addFace(int [] face) {

                hasFaces = true;

                if (faces == null)

                        faces = new Vector();

                faces.add(face);

        }

        private Color color = baseColor; //Color(255,214,132,255);

        public Color c() {return color;}

        public Color c(Color color) {this.color = color; return color;}

        public void reProject(ICoordTrans rp) {

                Vector savePts = pts;

                pts = new Vector();

                extent = new Extent();

                Point2D ptDest = null;

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

                        ptDest = rp.getPDest().createPoint(0.0,0.0);

                        ptDest = rp.convert((Point2D) savePts.get(i), ptDest);

                        pts.add(ptDest);

                        extent.add(ptDest);

                }

                setProjection(rp.getPDest());

        }

        public void draw(Graphics2D g, ViewPortData vp) {

                //AffineTransform msave=g.getTransform();

                //g.setTransform(vp.mat);

                Color color = null;

                // pinto el poligono si es preciso

                if (dxfColor == AcadColor.BYLAYER)

                        color = layer.getColor();

                else

                        color = AcadColor.getColor(dxfColor);

                System.out.println("PLINE color="+color);

                newGP(vp);

                if (closed) {

                        g.setColor(new Color(color.getRed(), color.getBlue(), color.getGreen(), 0x20));

                        g.fill(gp);

                } 

                g.setColor(color);

                g.draw(gp);

                //g.setTransform(msave);

        }

        private void newGP(ViewPortData vp) {

                //if (gp != null) return;

                gp = new GeneralPath();

                Point2D pt0 = null, pt=null, pt1=null;

                Point2D.Double ptTmp = new Point2D.Double(0.0, 0.0);

                if (! hasFaces) {

                        Iterator iter = pts.iterator();

                        while (iter.hasNext()) {

                                pt1 = (Point2D) iter.next();

                                vp.mat.transform(pt1, ptTmp);

                                if (pt0 == null) { 

                                        pt0 = ptTmp;

                                        gp.moveTo((float)ptTmp.getX(), (float)ptTmp.getY());

                                } else {

                                        gp.lineTo((float)ptTmp.getX(), (float)ptTmp.getY());

                                }

                        }

                        if (closed) {

                                gp.closePath();                        

                        }

                } else {

                        System.out.println("POLYLINE: caras=" +faces.size()+", puntos="+ pts.size());

                        int [] face;

                        int i0, i1;

                        Iterator iter = faces.iterator();

                        while (iter.hasNext()) {

                                face = (int []) iter.next();

                                i0 = face[3];

                                for (int i=0; i<4; i++) {

                                        i1 = face[i];

                                        if (i0 > 0) {

                                                pt0 = (Point2D) pts.get(i0-1);

                                                vp.mat.transform(pt0, ptTmp);

                                                gp.moveTo((float)ptTmp.getX(), (float)ptTmp.getY());

                                                pt1 = (Point2D) pts.get(Math.abs(i1)-1);

                                                vp.mat.transform(pt1, ptTmp);

                                                gp.lineTo((float)ptTmp.getX(), (float)ptTmp.getY());

                                        }

                                        i0 = i1;

                                }

                        }

                }

        }

        /**

         * Convierte a DXF.

         * 

         * @return Entity como String Dxf 

         */

        public String toDxfString() {

                StringBuffer sb = null;

                sb = new StringBuffer( DxfGroup.toString(0, "POLYLINE") );

                sb.append( DxfGroup.toString(5, getHandle()) );

                sb.append( DxfGroup.toString(100, "AcDbEntity") );

                sb.append( DxfGroup.toString(8, layer.getName()) );

                sb.append( DxfGroup.toString(62, dxfColor) );

                sb.append( DxfGroup.toString(100, "AcDb2dPolyline") );

                sb.append( DxfGroup.toString(70, flags) );

                sb.append( DxfGroup.toString(66, 1) );

                Point2D pt = null;

                Iterator iter = pts.iterator();

                System.out.println("pts.size() = " + pts.size());

                while (iter.hasNext()) {

                        pt = (Point2D) iter.next();

                        sb.append( DxfGroup.toString(0, "VERTEX") );

                        sb.append( DxfGroup.toString(5, getHandle()) );

                        sb.append( DxfGroup.toString(100, "AcDbEntity") );

                        sb.append( DxfGroup.toString(8, layer.getName()) );

                        sb.append( DxfGroup.toString(100, "AcDbVertex") );

                        sb.append( DxfGroup.toString(100, "AcDb2dVertex") );

                        sb.append( DxfGroup.toString(10, pt.getX(), 6) );

                        sb.append( DxfGroup.toString(20, pt.getY(), 6) );

                        sb.append( DxfGroup.toString(30, 0.0, 6) );

                }

                sb.append( DxfGroup.toString(0, "SEQEND") );

                sb.append( DxfGroup.toString(5, getHandle()) );

                sb.append( DxfGroup.toString(100, "AcDbEntity") );

                sb.append( DxfGroup.toString(8, layer.getName()) );

                return sb.toString();

        }

        /**

         * @return

         */

        public GeneralPath getGeneralPath(ViewPortData vp) {

                newGP(vp);

                return (GeneralPath) gp.clone();

        }

        public int getFlags() {

                return flags;

        }

        //public static DxfEntityList createArc(Point2D coord1, Point2D coord2, double bulge, Point3D xtru) {

        public static Vector createArc(Point2D coord1, Point2D coord2, double bulge) {

                //return new DxfCalArcs(coord1, coord2, bulge).getPoints(1, xtru);

                return new DxfCalArcs(coord1, coord2, bulge).getPoints(1);

        }

        /**

         * @return Returns the pts.

         */

        public Vector getPts() {

                return pts;

        }

        /**

         * @param pts The pts to set.

         */

        public void setPts(Vector pts) {

                this.pts = pts;

        }

        /**

         * @return Returns the bulges.

         */

        public Vector getBulges() {

                return bulges;

        }

        /**

         * @param bulges The bulges to set.

         */

        public void setBulges(Vector bulges) {

                this.bulges = bulges;

        }

}