| gvSIG desktop 1

/* jdwglib. Java Library for reading Dwg files.

 * 

 * Author: Jose Morell Rama (jose.morell@gmail.com).

 * Port from the Pythoncad Dwg library by Art Haas.

 *

 * Copyright (C) 2005 Jose Morell, IVER TI S.A. 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:

 *

 * Jose Morell (jose.morell@gmail.com)

 * 

 * or

 *

 * IVER TI S.A.

 *  C/Salamanca, 50

 *  46005 Valencia

 *  Spain

 *  +34 963163400

 *  dac@iver.es

 */

package com.iver.cit.jdwglib.dwg;

import java.awt.geom.Point2D;

import java.io.File;

import java.io.FileInputStream;

import java.io.IOException;

import java.nio.ByteBuffer;

import java.nio.channels.FileChannel;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.LinkedList;

import java.util.List;

import java.util.Map;

import com.iver.cit.jdwglib.dwg.objects.DwgArc;

import com.iver.cit.jdwglib.dwg.objects.DwgAttdef;

import com.iver.cit.jdwglib.dwg.objects.DwgAttrib;

import com.iver.cit.jdwglib.dwg.objects.DwgBlock;

import com.iver.cit.jdwglib.dwg.objects.DwgBlockHeader;

import com.iver.cit.jdwglib.dwg.objects.DwgCircle;

import com.iver.cit.jdwglib.dwg.objects.DwgEllipse;

import com.iver.cit.jdwglib.dwg.objects.DwgEndblk;

import com.iver.cit.jdwglib.dwg.objects.DwgInsert;

import com.iver.cit.jdwglib.dwg.objects.DwgLayer;

import com.iver.cit.jdwglib.dwg.objects.DwgLine;

import com.iver.cit.jdwglib.dwg.objects.DwgLwPolyline;

import com.iver.cit.jdwglib.dwg.objects.DwgMText;

import com.iver.cit.jdwglib.dwg.objects.DwgPoint;

import com.iver.cit.jdwglib.dwg.objects.DwgPolyline2D;

import com.iver.cit.jdwglib.dwg.objects.DwgPolyline3D;

import com.iver.cit.jdwglib.dwg.objects.DwgSeqend;

import com.iver.cit.jdwglib.dwg.objects.DwgSolid;

import com.iver.cit.jdwglib.dwg.objects.DwgText;

import com.iver.cit.jdwglib.dwg.objects.DwgVertex2D;

import com.iver.cit.jdwglib.dwg.readers.IDwgFileReader;

import com.iver.cit.jdwglib.dwg.readers.DwgFileV15Reader;

/**

 * The DwgFile class provides a revision-neutral interface for reading and handling

 * DWG files

 * Reading methods are useful for reading DWG files, and handling methods like

 * calculateDwgPolylines() are useful for handling more complex

 * objects in the DWG file

 * 

 * @author jmorell

 * @author azabala

 */

public class DwgFile {

        /**

         * It has all known DWG version's header.

         * Extracted from Autodesk web.

         */

        private static HashMap acadVersions = new HashMap();

        static{

                acadVersions.put("AC1004", "Autocad R9");

                acadVersions.put("AC1006", "Autocad R10");

                acadVersions.put("AC1007", "Autocad pre-R11");

                acadVersions.put("AC1007", "Autocad pre-R11");

                acadVersions.put("AC1008", "Autocad pre-R11b");

                acadVersions.put("AC1009", "Autocad R12");

                acadVersions.put("AC1010", "Autocad pre-R13 a");

                acadVersions.put("AC1011", "Autocad pre-R13 b");

                acadVersions.put("AC1012", "Autocad R13");

                acadVersions.put("AC1013", "Autocad pre-R14");

                acadVersions.put("AC1014", "Autocad R14");

                acadVersions.put("AC1500", "Autocad pre-2000");

                acadVersions.put("AC1015", "Autocad R2000, R2000i, R2002");

                acadVersions.put("AC402a", "Autocad pre-2004a");

                acadVersions.put("AC402b", "Autocad pre-2004b");

                acadVersions.put("AC1018", "Autocad R2004, R2005, R2006");

                acadVersions.put("AC1021", "Autocad R2007");

        }

        private String fileName;

        private String dwgVersion;

        /**

         * Offsets to the DWG sections

         */

        private ArrayList dwgSectionOffsets;

        /**

         * Header vars readed from the HEADER section of the DWG file

         * */

        private Map headerVars;

        /**

         * This list contains what in OpenDWG specification is called

         * the object map ( a collection of entries where each entry contains

         * the seek of each object, and its size)

         * */

        private ArrayList dwgObjectOffsets;

        /**

         * For each entry in dwgObjectOffsets, we have an instance of

         * DwgObject in the dwgObjects collection

         * 

         * */

        private LinkedList dwgObjects;

        private HashMap handle_objects;

        private ArrayList dwgClasses;

        /**

         * hash map that indexes all DwgLayer objects

         * by its handle property

         * */

        private HashMap layerTable; 

        /**

         * Specific reader of the DWG file version (12, 13, 14, 2000, etc., each

         * version will have an specific reader)

         * */

        private IDwgFileReader dwgReader;

        private boolean dwg3DFile;

        /**

         * Memory mapped byte buffer of the whole DWG file

         * */

        private ByteBuffer bb;

        /*

         * Optimizaciones para evitar leer el fichero completo en cada

         * pasada.

         * */

        /**

         * Contains all IDwgPolyline implementations

         * */

        private List dwgPolylines;

        /**

         * map of blocks dwg entities indexed by their names.

         */

        private Map names_blocks;

        /**

         * Constructor.

         * @param fileName an absolute path to the DWG file

         */

        public DwgFile(String fileName) {

                this.fileName = fileName;

                dwgSectionOffsets = new ArrayList();

                dwgObjectOffsets = new ArrayList();

                headerVars = new HashMap();

                //TODO Si finalmente no se leen las clases, quitar

                //dwgClasses

                dwgClasses = new ArrayList();

                dwgObjects = new LinkedList();

                handle_objects = new HashMap();

                layerTable = new HashMap();

                dwgPolylines = new ArrayList();

                names_blocks = new HashMap();

        }

        public String getDwgVersion() {

                return dwgVersion;

        }

        /**

         * Reads a DWG file and put its objects in the dwgObjects Vector

         * This method is version independent

         * 

         * @throws IOException If the file location is wrong

         */

        public void read() throws IOException, 

                                DwgVersionNotSupportedException

        {

                setDwgVersion();

                if (dwgVersion.equalsIgnoreCase("Autocad R2000, R2000i, R2002")) {

                        dwgReader = new DwgFileV15Reader();

                        dwgReader.read(this, bb);

                } else {

                        DwgVersionNotSupportedException exception = 

                                new DwgVersionNotSupportedException("Version de DWG no soportada");

                        exception.setDwgVersion(dwgVersion);

                        throw exception;

                }

        }

        private void setDwgVersion() throws IOException {

                File file = new File(fileName);

                FileInputStream fileInputStream = new FileInputStream(file);

                FileChannel fileChannel = fileInputStream.getChannel();

                long channelSize = fileChannel.size();

                bb = fileChannel.map(FileChannel.MapMode.READ_ONLY, 0, channelSize);

                byte[] versionBytes = {bb.get(0), 

                                                                bb.get(1), 

                                                                bb.get(2),

                                                                bb.get(3),

                                                                bb.get(4), 

                                                                bb.get(5)};

                ByteBuffer versionByteBuffer = ByteBuffer.wrap(versionBytes);

                String[] bs = new String[versionByteBuffer.capacity()];

                String versionString = "";

                for (int i=0; i<versionByteBuffer.capacity(); i++) {

                        bs[i] = new String(new byte[]{(byte)(versionByteBuffer.get(i))});

                        versionString = versionString + bs[i];

                }

                String version = (String) acadVersions.get(versionString);

                if(version == null)

                        version = "Unknown Dwg format";

                this.dwgVersion = version;    

        }

        public void setHeader(String key, Object value){

                headerVars.put(key, value);

        }

        /**

         * Initialize a new Vector that contains the DWG file layers. 

         * Each layer have three parameters. 

         * These parameters are handle, name and color

         */

//        public void initializeLayerTable() {

//                layerTable = new ArrayList();

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

//                        DwgObject obj = (DwgObject)dwgObjects.get(i);

//                        if (obj instanceof DwgLayer) {

//                                ArrayList layerTableRecord = new ArrayList();

//                                layerTableRecord.add(new Integer(obj.getHandle()));

//                                layerTableRecord.add(((DwgLayer)obj).getName());

//                                layerTableRecord.add(new Integer(((DwgLayer)obj).getColor()));

//                                layerTable.add(layerTableRecord);

//                        }

//                }

//        }

        /*

         * A DwgLayer is a DWG drawing entity, so all DwgLayer objects are

         * saved in dwgObjects collection.

         * Instead of iterate over the full collection, is faster check every object

         * and save all the DwgLayer instances in their own collection.

         *

         */

        public void addDwgLayer(DwgLayer dwgLayer){

                layerTable.put(new Integer(dwgLayer.getHandle()), 

                                dwgLayer);

        }

        public DwgLayer getDwgLayer(DwgObject entity){

                int handleCode = entity.getLayerHandleCode();

                int layerHandle = -1;

                int entityRecord;

                DwgObject object;

//                switch(handleCode){

//                        case 0x2:

//                        case 0x3:

//                        case 0x4:

//                        case 0x5:

//                                layerHandle = entity.getLayerHandle();

//                        break;

//                        

//                        case 0x6:

//                                entityRecord = entity.getIndex();

//                                object = this.getDwgObject(entityRecord + 1);

//                                layerHandle = object.getLayerHandle();

//                        break;

//                        case 0x8:

//                                entityRecord = entity.getIndex();

//                                object = this.getDwgObject(entityRecord - 1);

//                                layerHandle = object.getLayerHandle();

//                                

//                        break;

//                        case 0xA:

//                                //reference handle plus offset of layer handle??

//                                int handle = entity.getHandle();

//                                int offset = entity.getLayerHandle();

//                                layerHandle = handle + offset;

//                                

//                                

//                        break;

//                        case 0xC:

//                            //reference handle minus offset of layer handle??

//                                handle = entity.getHandle();

//                                offset = entity.getLayerHandle();

//                                layerHandle = handle + offset;

//                                

//                        break;

//                        default:

//                                System.out.println("Unknown layer handle code:"+handleCode);        

//                        return null;

//                }

                /*

                 * OpenDWG spec, v3, page 11. HANDLE REFERENCES

                 * 

                 * A handle is formed by this fields:

                 * a) CODE (4 bits)

                 * b) COUNTER (4 bits)

                 * c) OFFSET of the object (handle itself).

                 * 

                 * CODE could take these values:

                 * 1) 0x2, 0x3, 0x4, 0x5 -> offset is the handle of the layer

                 * 2) 0x6 -> offset is the next object handle

                 * 3) 0x8 -> offset is the previous object handle

                 * 4) 0xA -> result is reference handle plus offset

                  * 5) 0xC -> result is reference handle minus offset

                 * 

                 * */

//                Iterator lyrIterator = layerTable.values().iterator();

//                while(lyrIterator.hasNext()){

//                        DwgLayer lyr = (DwgLayer) lyrIterator.next();

//                        int lyrHdl = lyr.getHandle();

//                        int entityHdlCode = entity.getLayerHandleCode();

//                        int entityHdl = entity.getLayerHandle();

//                        int newLyrHdl = layerHandle;

//                        System.currentTimeMillis();

//                }

                return (DwgLayer) layerTable.

                                get(new Integer(layerHandle));

        }

        public String getLayerName(DwgObject entity) {                

                DwgLayer dwgLayer = getDwgLayer(entity);

                if(dwgLayer == null){//TODO Puede haber entidades sin layer???

                        return "";

                }else

                        return dwgLayer.getName();

        }

        /**

     * Returns the color of the layer of a DWG object 

         * 

     * @param entity DWG object which we want to know its layer color

         * @return int Layer color of the DWG object in the Autocad color code

         */

        public int getColorByLayer(DwgObject entity) {

                int colorByLayer;

                DwgLayer dwgLyr = getDwgLayer(entity);

                if(dwgLyr == null)

                        colorByLayer = 0;

                else

                        colorByLayer = dwgLyr.getColor();

                return colorByLayer;

        }

        //azabala: esto ahora se hace conforme se van creando los objetos

        //(y no al final en una segunda pasada

//    public void applyExtrusions() {

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

//            DwgObject dwgObject = (DwgObject)dwgObjects.get(i);

//            if(dwgObject instanceof IDwgExtrusionable){

//                    ((IDwgExtrusionable)dwgObject).applyExtrussion();

//            }

//            // Seems that Autocad don't apply the extrusion to Ellipses

//            /*} else if (dwgObject instanceof DwgEllipse) {

//                double[] ellipseCenter = ((DwgEllipse)dwgObject).getCenter();

//                double[] ellipseExt = ((DwgEllipse)dwgObject).getExtrusion();

//                ellipseCenter = AcadExtrusionCalculator.CalculateAcadExtrusion(ellipseCenter, ellipseExt);

//                ((DwgEllipse)dwgObject).setCenter(ellipseCenter);*/

//        }//for

//    }

        /**

         * Configure the geometry of the polylines in a DWG file from the vertex list in

         * this DWG file. This geometry is given by an array of Points.

         * Besides, manage closed polylines and polylines with bulges in a GIS Data model.

     * It means that the arcs of the polylines will be done through a set of points and

     * a distance between these points.

         */

        public void calculateGisModelDwgPolylines() {

                /*

                 * Ahora mismo esto se est? haciendo al final (en una segunda pasada)

                 * porque posiblemente una Linea requiera de vertices que vengan

                 * despues, lo que complicar?a bastante todo....

                 * */

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

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

//                        DwgObject pol = (DwgObject)dwgObjects.get(i);

                        DwgObject pol = (DwgObject)dwgPolylines.get(i);

                        if (pol instanceof IDwgPolyline) {

                                ((IDwgPolyline)pol).calculateGisModel(dwgObjects);

                        } 

                }

        }

    /**

     * Configure the geometry of the polylines in a DWG file from the vertex list in

     * this DWG file. This geometry is given by an array of Points

     * Besides, manage closed polylines and polylines with bulges in a GIS Data model.

     * It means that the arcs of the polylines will be done through a curvature

     * parameter called bulge associated with the points of the polyline.

     */

        //TODO Refactorizar para que solo se aplique a las Polilineas

        public void calculateCadModelDwgPolylines() {

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

                        DwgObject pol = (DwgObject)dwgObjects.get(i);

                        if (pol instanceof DwgPolyline2D) {

                                int flags = ((DwgPolyline2D)pol).getFlags();

                                int firstHandle = ((DwgPolyline2D)pol).getFirstVertexHandle();

                                int lastHandle = ((DwgPolyline2D)pol).getLastVertexHandle();

                                ArrayList pts = new ArrayList();

                                ArrayList bulges = new ArrayList();

                                double[] pt = new double[3];

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

                                        DwgObject firstVertex = (DwgObject)dwgObjects.get(j);

                                        if (firstVertex instanceof DwgVertex2D) {

                                                int vertexHandle = firstVertex.getHandle();

                                                if (vertexHandle==firstHandle) {

                                                        int k=0;

                                                        while (true) {

                                                                DwgObject vertex = (DwgObject)dwgObjects.get(j+k);

                                                                int vHandle = vertex.getHandle();

                                                                if (vertex instanceof DwgVertex2D) {

                                                                        pt = ((DwgVertex2D)vertex).getPoint();

                                                                        pts.add(new Point2D.Double(pt[0], pt[1]));

                                                                        double bulge = ((DwgVertex2D)vertex).getBulge();

                                                                        bulges.add(new Double(bulge));

                                                                        k++;

                                                                        if (vHandle==lastHandle && vertex instanceof DwgVertex2D) {

                                                                                break;

                                                                        }

                                                                } else if (vertex instanceof DwgSeqend) {

                                                                        break;

                                                                }

                                                        }

                                                }

                                        }

                                }

                                if (pts.size()>0) {

                                        /*Point2D[] newPts = new Point2D[pts.size()];

                                        if ((flags & 0x1)==0x1) {

                                                newPts = new Point2D[pts.size()+1];

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

                                                        newPts[j] = (Point2D)pts.get(j);

                                                }

                                                newPts[pts.size()] = (Point2D)pts.get(0);

                                                bulges.add(new Double(0));

                                        } else {

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

                                                        newPts[j] = (Point2D)pts.get(j);

                                                }

                                        }*/

                                        double[] bs = new double[bulges.size()];

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

                                                bs[j] = ((Double)bulges.get(j)).doubleValue();

                                        }

                                        ((DwgPolyline2D)pol).setBulges(bs);

                                        //Point2D[] points = GisModelCurveCalculator.calculateGisModelBulge(newPts, bs);

                                        Point2D[] points = new Point2D[pts.size()];

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

                                            points[j] = (Point2D)pts.get(j);

                                        }

                                        ((DwgPolyline2D)pol).setPts(points);

                                } else {

//                                        System.out.println("Encontrada polil?nea sin puntos ...");

                                        // TODO: No se debe mandar nunca una polil?nea sin puntos, si esto

                                        // ocurre es porque existe un error que hay que corregir ...

                                }

                        } else if (pol instanceof DwgPolyline3D) {

                        } else if (pol instanceof DwgLwPolyline && ((DwgLwPolyline)pol).getVertices()!=null) {

                        }

                }

        }

    /**

     * Changes the location of an object extracted from a block. This location will be

     * obtained through the insertion parameters from the block and the corresponding

     * insert.

     * @param entity, the entity extracted from the block.

     * @param bPoint, offset for the coordinates of the entity.

     * @param insPoint, coordinates of the insertion point for the entity.

     * @param scale, scale for the entity.

     * @param rot, rotation angle for the entity.

     * @param id, a count as a id.

     * @param dwgObjectsWithoutBlocks, a object list with the elements extracted from

     * the blocks.

     */

        private void manageBlockEntity(DwgObject entity, double[] bPoint, Point2D insPoint, double[] scale, double rot, List dwgObjectsWithoutBlocks) {

                if (entity instanceof DwgArc) {

                        //System.out.println("Encuentra un arco dentro de un bloque ...");

                        DwgArc transformedEntity = new DwgArc(entity.getIndex());

                        double[] center = ((DwgArc)entity).getCenter();

                        Point2D pointAux = new Point2D.Double(center[0] - bPoint[0], center[1] - bPoint[1]);

                        double laX = insPoint.getX() + ((pointAux.getX()*scale[0])*Math.cos(rot) + (pointAux.getY()*scale[1])*(-1)*Math.sin(rot));

                        double laY = insPoint.getY() + ((pointAux.getX()*scale[0])*Math.sin(rot) + (pointAux.getY()*scale[1])*Math.cos(rot));

                        double laZ = center[2] * scale[2];

                        double[] transformedCenter = new double[]{laX, laY, laZ};

                        double radius = ((DwgArc)entity).getRadius();

                        double transformedRadius = radius * scale[0];

                        double initAngle = ((DwgArc)entity).getInitAngle();

                        double endAngle = ((DwgArc)entity).getEndAngle();

            double transformedInitAngle = initAngle + rot;

            if (transformedInitAngle<0) {

                transformedInitAngle = transformedInitAngle + (2*Math.PI);

            } else if (transformedInitAngle>(2*Math.PI)) {

                transformedInitAngle = transformedInitAngle - (2*Math.PI);

            }

            double transformedEndAngle = endAngle + rot;

            if (transformedEndAngle<0) {

                transformedEndAngle = transformedEndAngle + (2*Math.PI);

            } else if (transformedEndAngle>(2*Math.PI)) {

                transformedEndAngle = transformedEndAngle - (2*Math.PI);

            }

                        transformedEntity = (DwgArc)((DwgArc)entity).clone();

                        transformedEntity.setCenter(transformedCenter);

                        transformedEntity.setRadius(transformedRadius);

                        transformedEntity.setInitAngle(transformedInitAngle);

                        transformedEntity.setEndAngle(transformedEndAngle);

                        dwgObjectsWithoutBlocks.add(transformedEntity);

                } else if (entity instanceof DwgCircle) {

                        //System.out.println("Encuentra un c?rculo dentro de un bloque ...");

                        DwgCircle transformedEntity = new DwgCircle(entity.getIndex());

                        double[] center = ((DwgCircle)entity).getCenter();

                        Point2D pointAux = new Point2D.Double(center[0] - bPoint[0], center[1] - bPoint[1]);

                        double laX = insPoint.getX() + ((pointAux.getX()*scale[0])*Math.cos(rot) + (pointAux.getY()*scale[1])*(-1)*Math.sin(rot));

                        double laY = insPoint.getY() + ((pointAux.getX()*scale[0])*Math.sin(rot) + (pointAux.getY()*scale[1])*Math.cos(rot));

                        double laZ = center[2] * scale[2];

                        double[] transformedCenter = new double[]{laX, laY, laZ};

                        double radius = ((DwgCircle)entity).getRadius();

                        double transformedRadius = radius * scale[0];

                        transformedEntity = (DwgCircle)((DwgCircle)entity).clone();

                        transformedEntity.setCenter(transformedCenter);

                        transformedEntity.setRadius(transformedRadius);

                        dwgObjectsWithoutBlocks.add(transformedEntity);

                } else if (entity instanceof DwgEllipse) {

                        DwgEllipse transformedEntity = new DwgEllipse(entity.getIndex());

                        double[] center = ((DwgEllipse)entity).getCenter();

                        Point2D pointAux = new Point2D.Double(center[0] - bPoint[0], center[1] - bPoint[1]);

                        double laX = insPoint.getX() + ((pointAux.getX()*scale[0])*Math.cos(rot) + (pointAux.getY()*scale[1])*(-1)*Math.sin(rot));

                        double laY = insPoint.getY() + ((pointAux.getX()*scale[0])*Math.sin(rot) + (pointAux.getY()*scale[1])*Math.cos(rot));

                        double laZ = center[2] * scale[2];

                        double[] transformedCenter = new double[]{laX, laY, laZ};

                        double[] majorAxisVector = ((DwgEllipse)entity).getMajorAxisVector();

                        double[] transformedMajorAxisVector = new double[]{majorAxisVector[0] * scale[0], majorAxisVector[1] * scale[1], majorAxisVector[2] * scale[2]};

                        //TODO: Rotar un ?ngulo rot el vector majorAxisVector fijado en

                        // center.

                        double axisRatio = ((DwgEllipse)entity).getAxisRatio();

                        double transformedAxisRatio = axisRatio;

                        double initAngle = ((DwgEllipse)entity).getInitAngle();

                        double endAngle = ((DwgEllipse)entity).getEndAngle();

            double transformedInitAngle = initAngle + rot;

            if (transformedInitAngle<0) {

                transformedInitAngle = transformedInitAngle + (2*Math.PI);

            } else if (transformedInitAngle>(2*Math.PI)) {

                transformedInitAngle = transformedInitAngle - (2*Math.PI);

            }

            double transformedEndAngle = endAngle + rot;

            if (transformedEndAngle<0) {

                transformedEndAngle = transformedEndAngle + (2*Math.PI);

            } else if (transformedEndAngle>(2*Math.PI)) {

                transformedEndAngle = transformedEndAngle - (2*Math.PI);

            }

                        transformedEntity = (DwgEllipse)((DwgEllipse)entity).clone();

                        transformedEntity.setCenter(transformedCenter);

                        transformedEntity.setMajorAxisVector(transformedMajorAxisVector);

                        transformedEntity.setAxisRatio(transformedAxisRatio);

                        transformedEntity.setInitAngle(transformedInitAngle);

                        transformedEntity.setEndAngle(transformedEndAngle);

                        dwgObjectsWithoutBlocks.add(transformedEntity);

                } else if (entity instanceof DwgLine) {

                        //System.out.println("Encuentra una l?nea dentro de un bloque ...");

                        DwgLine transformedEntity = new DwgLine(entity.getIndex());

                        double[] p1 = ((DwgLine)entity).getP1();

                        double[] p2 = ((DwgLine)entity).getP2();

                        Point2D pointAux = new Point2D.Double(p1[0] - bPoint[0], p1[1] - bPoint[1]);

                        double laX = insPoint.getX() + ((pointAux.getX()*scale[0])*Math.cos(rot) + (pointAux.getY()*scale[1])*(-1)*Math.sin(rot));

                        double laY = insPoint.getY() + ((pointAux.getX()*scale[0])*Math.sin(rot) + (pointAux.getY()*scale[1])*Math.cos(rot));

                        double[] transformedP1 = null;

            if (((DwgLine)entity).isZflag()) {

                                double laZ = p1[2] * scale[2];

                                transformedP1 = new double[]{laX, laY, laZ};

                        } else {

                                transformedP1 = new double[]{laX, laY};

                        }

                        //double[] transformedP1 = new double[]{laX, laY};

                        pointAux = new Point2D.Double(p2[0] - bPoint[0], p2[1] - bPoint[1]);

                        laX = insPoint.getX() + ((pointAux.getX()*scale[0])*Math.cos(rot) + (pointAux.getY()*scale[1])*(-1)*Math.sin(rot));

                        laY = insPoint.getY() + ((pointAux.getX()*scale[0])*Math.sin(rot) + (pointAux.getY()*scale[1])*Math.cos(rot));

            double[] transformedP2 = null;

                        if (((DwgLine)entity).isZflag()) {

                                double laZ = p2[2] * scale[2];

                                transformedP2 = new double[]{laX, laY, laZ};

                        } else {

                                transformedP2 = new double[]{laX, laY};

                        }

                        //double[] transformedP2 = new double[]{laX, laY};

                        transformedEntity = (DwgLine)((DwgLine)entity).clone();

                        transformedEntity.setP1(transformedP1);

                        transformedEntity.setP2(transformedP2);

                        dwgObjectsWithoutBlocks.add(transformedEntity);

                } else if (entity instanceof DwgLwPolyline) {

            //System.out.println("Encuentra una DwgLwPolyline dentro de un bloque ...");

                        DwgLwPolyline transformedEntity = new DwgLwPolyline(entity.getIndex());

                        Point2D[] vertices = ((DwgLwPolyline)entity).getVertices();

                        if (vertices!=null) {

                            Point2D[] transformedVertices = new Point2D[vertices.length];

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

                                    Point2D pointAux = new Point2D.Double(vertices[i].getX() - bPoint[0], vertices[i].getY() - bPoint[1]);

                                        double laX = insPoint.getX() + ((pointAux.getX()*scale[0])*Math.cos(rot) + (pointAux.getY()*scale[1])*(-1)*Math.sin(rot));

                                        double laY = insPoint.getY() + ((pointAux.getX()*scale[0])*Math.sin(rot) + (pointAux.getY()*scale[1])*Math.cos(rot));

                                        transformedVertices[i] = new Point2D.Double(laX, laY);

                                }

                                transformedEntity = (DwgLwPolyline)((DwgLwPolyline)entity).clone();

                                transformedEntity.setVertices(transformedVertices);

                                transformedEntity.setElevation(((DwgLwPolyline)entity).getElevation() * scale[2]);

                                dwgObjectsWithoutBlocks.add(transformedEntity);

                        }

                } else if (entity instanceof DwgMText) {

                } else if (entity instanceof DwgPoint) {

                } else if (entity instanceof DwgPolyline2D) {

                        //System.out.println("Encuentra una polil?nea dentro de un bloque ...");

                        DwgPolyline2D transformedEntity = new DwgPolyline2D(entity.getIndex());

                        Point2D[] vertices = ((DwgPolyline2D)entity).getPts();

                        if (vertices!=null) {

                            Point2D[] transformedVertices = new Point2D[vertices.length];

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

                                    Point2D pointAux = new Point2D.Double(vertices[i].getX() - bPoint[0], vertices[i].getY() - bPoint[1]);

                                        double laX = insPoint.getX() + ((pointAux.getX()*scale[0])*Math.cos(rot) + (pointAux.getY()*scale[1])*(-1)*Math.sin(rot));

                                        double laY = insPoint.getY() + ((pointAux.getX()*scale[0])*Math.sin(rot) + (pointAux.getY()*scale[1])*Math.cos(rot));

                                        transformedVertices[i] = new Point2D.Double(laX, laY);

                                }

                                transformedEntity = (DwgPolyline2D)((DwgPolyline2D)entity).clone();

                                transformedEntity.setPts(transformedVertices);

                                transformedEntity.setElevation(((DwgPolyline2D)entity).getElevation() * scale[2]);

                                dwgObjectsWithoutBlocks.add(transformedEntity);

                        }

                } else if (entity instanceof DwgPolyline3D) {

                } else if (entity instanceof DwgSolid) {

                        DwgSolid transformedEntity = new DwgSolid(entity.getIndex());

                        double[] corner1 = ((DwgSolid)entity).getCorner1();

                        double[] corner2 = ((DwgSolid)entity).getCorner2();

                        double[] corner3 = ((DwgSolid)entity).getCorner3();

                        double[] corner4 = ((DwgSolid)entity).getCorner4();

                        Point2D pointAux = new Point2D.Double(corner1[0] - bPoint[0], corner1[1] - bPoint[1]);

                        double laX = insPoint.getX() + ((pointAux.getX()*scale[0])*Math.cos(rot) + (pointAux.getY()*scale[1])*(-1)*Math.sin(rot));

                        double laY = insPoint.getY() + ((pointAux.getX()*scale[0])*Math.sin(rot) + (pointAux.getY()*scale[1])*Math.cos(rot));

                        double[] transformedP1 = new double[]{laX, laY};

                        pointAux = new Point2D.Double(corner2[0] - bPoint[0], corner2[1] - bPoint[1]);

                        laX = insPoint.getX() + ((pointAux.getX()*scale[0])*Math.cos(rot) + (pointAux.getY()*scale[1])*(-1)*Math.sin(rot));

                        laY = insPoint.getY() + ((pointAux.getX()*scale[0])*Math.sin(rot) + (pointAux.getY()*scale[1])*Math.cos(rot));

                        double[] transformedP2 = new double[]{laX, laY};

                        pointAux = new Point2D.Double(corner3[0] - bPoint[0], corner3[1] - bPoint[1]);

                        laX = insPoint.getX() + ((pointAux.getX()*scale[0])*Math.cos(rot) + (pointAux.getY()*scale[1])*(-1)*Math.sin(rot));

                        laY = insPoint.getY() + ((pointAux.getX()*scale[0])*Math.sin(rot) + (pointAux.getY()*scale[1])*Math.cos(rot));

                        double[] transformedP3 = new double[]{laX, laY};

                        pointAux = new Point2D.Double(corner4[0] - bPoint[0], corner4[1] - bPoint[1]);

                        laX = insPoint.getX() + ((pointAux.getX()*scale[0])*Math.cos(rot) + (pointAux.getY()*scale[1])*(-1)*Math.sin(rot));

                        laY = insPoint.getY() + ((pointAux.getX()*scale[0])*Math.sin(rot) + (pointAux.getY()*scale[1])*Math.cos(rot));

                        double[] transformedP4 = new double[]{laX, laY};

                        transformedEntity = (DwgSolid)((DwgSolid)entity).clone();

                        transformedEntity.setCorner1(transformedP1);

                        transformedEntity.setCorner2(transformedP2);

                        transformedEntity.setCorner3(transformedP3);

                        transformedEntity.setCorner4(transformedP4);

                        transformedEntity.setElevation(((DwgSolid)entity).getElevation() * scale[2]);

                        dwgObjectsWithoutBlocks.add(transformedEntity);

                } else if (entity instanceof DwgInsert) {

                        //System.out.println("Encuentra un insert dentro de un bloque ...");

                        DwgInsert transformedEntity = new DwgInsert(entity.getIndex());

                        double[] p = ((DwgInsert)entity).getInsertionPoint();

                        Point2D point = new Point2D.Double(p[0], p[1]);

                        double[] newScale = ((DwgInsert)entity).getScale();

                        double newRot = ((DwgInsert)entity).getRotation();

                        int newBlockHandle = ((DwgInsert)entity).getBlockHeaderHandle();

                        Point2D pointAux = new Point2D.Double(point.getX() - bPoint[0], point.getY() - bPoint[1]);

                        double laX = insPoint.getX() + ((pointAux.getX()*scale[0])*Math.cos(rot) + (pointAux.getY()*scale[1])*(-1)*Math.sin(rot));

                        double laY = insPoint.getY() + ((pointAux.getX()*scale[0])*Math.sin(rot) + (pointAux.getY()*scale[1])*Math.cos(rot));

                        double laZ = p[2] * scale[2];

                        Point2D newInsPoint = new Point2D.Double(laX, laY);

                        newScale = new double[]{scale[0]*newScale[0], scale[1]*newScale[1], scale[2]*newScale[2]};

            newRot = newRot + rot;

            if (newRot<0) {

                newRot = newRot + (2*Math.PI);

            } else if (newRot>(2*Math.PI)) {

                newRot = newRot - (2*Math.PI);

            }

                        manageInsert2(newInsPoint, newScale, newRot, newBlockHandle, dwgObjectsWithoutBlocks);

                }

        }

    /**

     * Modify the geometry of the objects contained in the blocks of a DWG file and

     * add these objects to the DWG object list.

     * 

     */

        public void blockManagement() {

                LinkedList dwgObjectsWithoutBlocks = new LinkedList();

            boolean addingToBlock = false;

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

                        DwgObject entity = (DwgObject)dwgObjects.get(i);

                        if (entity instanceof DwgArc && !addingToBlock) {

                                dwgObjectsWithoutBlocks.add(entity);

                        } else if (entity instanceof DwgEllipse && !addingToBlock) {

                                dwgObjectsWithoutBlocks.add(entity);

                        } else if (entity instanceof DwgCircle && !addingToBlock) {

                                dwgObjectsWithoutBlocks.add(entity);

                        } else if (entity instanceof DwgPolyline2D && !addingToBlock) {

                                dwgObjectsWithoutBlocks.add(entity);

                        } else if (entity instanceof DwgPolyline3D && !addingToBlock) {

                                dwgObjectsWithoutBlocks.add(entity);

                        } else if (entity instanceof DwgLwPolyline && !addingToBlock) {

                                dwgObjectsWithoutBlocks.add(entity);

                        } else if (entity instanceof DwgSolid && !addingToBlock) {

                                dwgObjectsWithoutBlocks.add(entity);

                        } else if (entity instanceof DwgLine && !addingToBlock) {

                                dwgObjectsWithoutBlocks.add(entity);

                        } else if (entity instanceof DwgPoint && !addingToBlock) {

                                dwgObjectsWithoutBlocks.add(entity);

                        } else if (entity instanceof DwgMText && !addingToBlock) {

                                dwgObjectsWithoutBlocks.add(entity);

                        } else if (entity instanceof DwgText && !addingToBlock) {

                                dwgObjectsWithoutBlocks.add(entity);

                        } else if (entity instanceof DwgAttrib && !addingToBlock) {

                                dwgObjectsWithoutBlocks.add(entity);

                        } else if (entity instanceof DwgAttdef && !addingToBlock) {

                                dwgObjectsWithoutBlocks.add(entity);

                        } else if (entity instanceof DwgBlock) {

                                addingToBlock = true;

                        } else if (entity instanceof DwgEndblk) {

                                addingToBlock = false;

                        } else if (entity instanceof DwgBlockHeader) {

                                addingToBlock = true;

                        } 

                        else if (entity instanceof DwgInsert && !addingToBlock) {

                                double[] p = ((DwgInsert)entity).getInsertionPoint();

                                Point2D point = new Point2D.Double(p[0], p[1]);

                                double[] scale = ((DwgInsert)entity).getScale();

                                double rot = ((DwgInsert)entity).getRotation();

                                int blockHandle = ((DwgInsert)entity).getBlockHeaderHandle();

                                manageInsert2(point, scale, rot, blockHandle, dwgObjectsWithoutBlocks);

                        } else {

                                System.out.println(entity.getClass().getName() +" en un bloque");

                        }

                }

                dwgObjects = dwgObjectsWithoutBlocks;

        }

    /**

     * Manages an INSERT of a DWG file. This object is the insertion point of a DWG

     * block. 

     * 

     * @param insPoint, coordinates of the insertion point.

     * @param scale, scale of the elements of the block that will be inserted.

     * @param rot, rotation angle of the elements of the block.

     * 

     * @param bHandle, offset for the coordinates of the elements of the block.

     * @param id, count that serves as a id.

     * @param dwgObjectsWithoutBlocks, a object list with the elements extracted from

     * the blocks.

     */

        public void manageInsert2(Point2D insPoint, double[] scale,

                                                        double rot, int bHandle, 

                                                        List dwgObjectsWithoutBlocks) {

                DwgObject object = (DwgObject) handle_objects.get(new Integer(bHandle));

                if(! (object instanceof DwgBlockHeader)){

                        //Hay un problema con la asignaci?n de handle

                        //Un INSERT tiene como handle de Block una entidad que no es block

                        System.out.println("handle incorrecto." + object.getClass().getName() + " no es un blockheader");

                        return;

                }

                DwgBlockHeader blockHeader = (DwgBlockHeader)object;

                double[] bPoint = blockHeader.getBasePoint();

                String bname = blockHeader.getName();

                if (bname.startsWith("*")) 

                        return;

                int firstObjectHandle = blockHeader.getFirstEntityHandle();   

                int lastObjectHandle = blockHeader.getLastEntityHandle();

                //TODO Ver que hacia el metodo antiguo cuando llegaban handles a 0

                //como extremos de un bloque (sera bloque vacio, supongo)

                if(firstObjectHandle == 0 || lastObjectHandle == 0){

                        System.out.println("Problemas en el bloque "+bname);

                        System.out.println("1er obj="+firstObjectHandle+" 2o obj="+lastObjectHandle);

                        return;

                }        

                //Busca el bloque cuyo nombre sea bname

//                El bloque no se usa para nada DwgBlock block = (DwgBlock) names_blocks.get(bname);

                /*

                 * Ahora localiza la primera entidad del bloque, 

                 * y a partir de ah?, a?ade

                 * al bloque todas las entidades que encuentre hasta la 

                 * ?ltima entidad del bloque

                 * 

                 * */

                 DwgObject firstObj = (DwgObject) handle_objects.

                                                 get(new Integer(firstObjectHandle));

                 DwgObject lastObj =  (DwgObject) handle_objects.

                                                 get(new Integer(lastObjectHandle));

                 int firstObjIdx = dwgObjects.indexOf(firstObj);

                 int lastObjIdx = dwgObjects.indexOf(lastObj);

                 if(firstObjIdx == -1 || lastObjIdx == -1){

                         System.out.println("Problemas en la LinkedList: 1?="+firstObjIdx+",Ultimo="+lastObjIdx);

                 }

                 for(int i = firstObjIdx; i <= lastObjIdx; i++){

                         DwgObject obj = (DwgObject) dwgObjects.get(i);

                         manageBlockEntity(obj, bPoint, 

                                                           insPoint, scale, 

                                                           rot, dwgObjectsWithoutBlocks);

                 }//for

        }

    /**

     * Changes the location of an object extracted from a block. This location will be

     * obtained through the insertion parameters from the block and the corresponding

     * insert.

     * @param entity, the entity extracted from the block.

     * @param bPoint, offset for the coordinates of the entity.

     * @param insPoint, coordinates of the insertion point for the entity.

     * @param scale, scale for the entity.

     * @param rot, rotation angle for the entity.

     * @param id, a count as a id.

     * @param dwgObjectsWithoutBlocks, a object list with the elements extracted from

     * the blocks.

     */

        private void manageBlockEntity2(DwgObject entity, 

                                                                        double[] bPoint, 

                                                                        Point2D insPoint, 

                                                                        double[] scale, 

                                                                        double rot, 

                                                                        List dwgObjectsWithoutBlocks) {

                if(entity instanceof IDwgBlockMember){

                        IDwgBlockMember blockMember = (IDwgBlockMember)entity;

                        blockMember.transform2Block(bPoint, insPoint, scale, rot, dwgObjectsWithoutBlocks, this);

                }

        }

        /*

         * azabala: Esto ahora se hace mientras las entidades dwg

         * se van creando, y no en una segunda pasada

         * */

        /*

        public void testDwg3D() {

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

                        DwgObject obj = (DwgObject)dwgObjects.get(i);

                        if(obj instanceof IDwg3DTestable){

                                if(((IDwg3DTestable)obj).has3DData())

                                        dwg3DFile = true;

                                return;

                        }

                        //} else if (obj instanceof DwgLinearDimension) {

                        //        z = ((DwgLinearDimension)obj).getElevation();

                        //        if (z!=0.0) dwg3DFile = true;         

                }//for

                dwg3DFile = false;

        }

        */

        /**

         * Add a DWG section offset to the dwgSectionOffsets vector

         * 

         * @param key Define the DWG section

         * @param seek Offset of the section

         * @param size Size of the section

         */

        public void addDwgSectionOffset(String key, int seek, int size) {

                DwgSectionOffset dso = new DwgSectionOffset(key, seek, size);

                dwgSectionOffsets.add(dso);

        }

        /**

     * Returns the offset of DWG section given by its key 

         * 

     * @param key Define the DWG section

         * @return int Offset of the section in the DWG file

         */

        public int getDwgSectionOffset(String key) {

                int offset = 0;

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

                        DwgSectionOffset dso = (DwgSectionOffset)dwgSectionOffsets.get(i);

                        String ikey = dso.getKey();

                        if (key.equals(ikey)) {

                                offset = dso.getSeek();

                                break;

                        }

                }

                return offset;

        }

        /**

         * Add a DWG object offset to the dwgObjectOffsets vector

         * 

         * @param handle Object handle

         * @param offset Offset of the object data in the DWG file

         */

        public void addDwgObjectOffset(int handle, int offset) {

                DwgObjectOffset doo = new DwgObjectOffset(handle, offset);

                dwgObjectOffsets.add(doo);

        }

        /**

         * 

         * Add a DWG object to the dwgObject vector

         * 

         * @param dwgObject DWG object

         */

        public void addDwgObject(DwgObject dwgObject){

                //TODO Ver si puedo inicializar las listas especificas

                //(IDwgPolyline, etc) aqu? 

                dwgObjects.add(dwgObject);

                handle_objects.put(new Integer(dwgObject.getHandle()), dwgObject);

                /*

                 * TODO Quitar todos estos if-then y sustituirlos por un metodo callbackj

                 * 

                 * 

                 * (dwgObject.init(this), y que cada objeto haga lo que tenga que hacer

                 * */

                if(dwgObject instanceof DwgLayer){

                        this.addDwgLayer((DwgLayer) dwgObject);

                }

                if(dwgObject instanceof IDwgExtrusionable){

                        ((IDwgExtrusionable)dwgObject).applyExtrussion();

                }

                if(dwgObject instanceof IDwgPolyline){

                        dwgPolylines.add(dwgObject);

                }

                if(dwgObject instanceof IDwg3DTestable){

                        if(! dwg3DFile){//if its true, we dont check again

                                dwg3DFile = ((IDwg3DTestable)dwgObject).has3DData();

                        }

                }

                if(dwgObject instanceof DwgBlock){

                        DwgBlock block = (DwgBlock) dwgObject;

                        names_blocks.put(block.getName(), block);

                }

        }

        /**

         * Returns dwgObjects from its insertion order (position

         * in the dwg file)

         * 

         * @param index order in the dwg file

         * @return position

         * */

        public DwgObject getDwgObject(int index){

                return (DwgObject) dwgObjects.get(index);

        }

        public DwgObject getDwgObjectFromHandle(int handle){

                return (DwgObject) handle_objects.get(new Integer(handle));

        }

        /**

         * Add a DWG class to the dwgClasses vector

         * 

         * @param dwgClass DWG class

         */

        public void addDwgClass(DwgClass dwgClass){

                dwgClasses.add(dwgClass);

        }

        public List getDwgClasses(){

                return dwgClasses;

        }

    /**

     * @return Returns the dwgObjectOffsets.

     */

    public ArrayList getDwgObjectOffsets() {

        return dwgObjectOffsets;

    }

    /**

     * @return Returns the dwgObjects.

     */

    public LinkedList getDwgObjects() {

        return dwgObjects;

    }

    /**

     * @return Returns the fileName.

     */

    public String getFileName() {

        return fileName;

    }

    /**

     * @return Returns the dwg3DFile.

     */

    public boolean isDwg3DFile() {

        return dwg3DFile;

    }

    /**

     * @param dwg3DFile The dwg3DFile to set.

     */

    public void setDwg3DFile(boolean dwg3DFile) {

        this.dwg3DFile = dwg3DFile;

    }

}