Application: gvSIG desktop » gvSIG data provider for DGN

/* gvSIG. Geographic Information System of the Valencian Government

 *

 * Copyright (C) 2007-2008 Infrastructures and Transports Department

 * of the Valencian Government (CIT)

 *

 * 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., 51 Franklin Street, Fifth Floor, Boston,

 * MA  02110-1301, USA.

 *

 */

/*

* AUTHORS (In addition to CIT):

* 2008 IVER T.I. S.A.   {{Task}}

*/

package org.gvsig.fmap.dal.store.dgn;

import java.io.File;

import org.gvsig.fmap.dal.DataStoreParameters;

import org.gvsig.fmap.dal.exception.DataException;

import org.gvsig.fmap.dal.feature.BaseTestFeatureStore;

import org.gvsig.fmap.dal.feature.FeatureStore;

public class TestDGN extends BaseTestFeatureStore {

	public static final File file_prueba = new File(TestDGN.class.getResource(

			"data/prueba.dgn").getFile());

	/*

	 * (non-Javadoc)

	 *

	 * @see

	 * org.gvsig.fmap.dal.feature.BaseTestFeatureStore#getDefaultDataStoreParameters

	 * ()

	 */

	public DataStoreParameters getDefaultDataStoreParameters()

			throws DataException {

		DGNStoreParameters dgnParameters = null;

		dgnParameters = (DGNStoreParameters) dataManager

				.createStoreParameters(DGNStoreProvider.NAME);

		dgnParameters.setFile(file_prueba.getAbsolutePath());

		dgnParameters.setCRS("EPSG:23030");

		return dgnParameters;

	}

	/*

	 * (non-Javadoc)

	 *

	 * @see org.gvsig.fmap.dal.feature.BaseTestFeatureStore#hasExplorer()

	 */

	public boolean hasExplorer() {

		// TODO Auto-generated method stub

		return false;

	}

	public boolean usesResources() {

		return true;

	}

	public void testLegendAndLabeling() throws Exception {

		FeatureStore store = (FeatureStore) dataManager

				.createStore(getDefaultDataStoreParameters());

		assertNotNull(store.invokeDynMethod("getLegend", null));

		assertNotNull(store.invokeDynMethod("getLabeling", null));

		store.dispose();

	}

}

package org.gvsig.fmap.dal.store.dgn;

import org.gvsig.fmap.dal.feature.spi.FeatureProvider;

import org.gvsig.fmap.dal.feature.spi.FeatureStoreProvider;

import org.gvsig.fmap.dal.store.dgn.lib.DGNReader;

public interface LegendBuilder {

	final public static String DYNMETHOD_BUILDER_NAME = "getLegendBuilder";

	final public static String DYNMETHOD_GETLEGEND_NAME = "getLegend";

	final public static String DYNMETHOD_GETLABELING_NAME = "getLabeling";

	public LegendBuilder initialize(FeatureStoreProvider store);

	public void begin();

	public void process(FeatureProvider feature, DGNReader dgnReader);

	public void end();

	public Object getLegend();

	public Object getLabeling();

}

/**

 * gvSIG. Desktop Geographic Information System.

 *

 * Copyright (C) 2007-2013 gvSIG Association.

 *

 * 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 3 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., 51

 * Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.

 *

 * For any additional information, do not hesitate to contact us at info AT

 * gvsig.com, or visit our website www.gvsig.com.

 */

package org.gvsig.fmap.dal.store.dgn.lib;

import java.awt.Color;

import java.awt.geom.Rectangle2D;

import java.io.FileInputStream;

import java.io.FileNotFoundException;

import java.nio.ByteBuffer;

import java.nio.ByteOrder;

import java.nio.MappedByteBuffer;

import java.nio.channels.FileChannel;

import java.text.MessageFormat;

import java.util.ArrayList;

import java.util.Formatter;

import java.util.Iterator;

import java.util.LinkedHashMap;

import java.util.List;

import java.util.Map;

import org.gvsig.fmap.dal.exception.DataException;

import org.gvsig.fmap.dal.exception.ReadException;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 * Clase dedicada a leer del fichero DGN.

 *

 */

public class DGNReader {

    private static Logger logger = LoggerFactory.getLogger(DGNReader.class);

    static int[][] abyDefaultPCT = {{255, 255, 255}, {0, 0, 255},

    {0, 255, 0}, {255, 0, 0}, {255, 255, 0}, {255, 0, 255},

    {255, 127, 0}, {0, 255, 255}, {64, 64, 64},

    {192, 192, 192}, {254, 0, 96}, {160, 224, 0},

    {0, 254, 160}, {128, 0, 160}, {176, 176, 176},

    {0, 240, 240}, {240, 240, 240}, {0, 0, 240}, {0, 240, 0},

    {240, 0, 0}, {240, 240, 0}, {240, 0, 240}, {240, 122, 0},

    {0, 240, 240}, {240, 240, 240}, {0, 0, 240}, {0, 240, 0},

    {240, 0, 0}, {240, 240, 0}, {240, 0, 240}, {240, 122, 0},

    {0, 225, 225}, {225, 225, 225}, {0, 0, 225}, {0, 225, 0},

    {225, 0, 0}, {225, 225, 0}, {225, 0, 225}, {225, 117, 0},

    {0, 225, 225}, {225, 225, 225}, {0, 0, 225}, {0, 225, 0},

    {225, 0, 0}, {225, 225, 0}, {225, 0, 225}, {225, 117, 0},

    {0, 210, 210}, {210, 210, 210}, {0, 0, 210}, {0, 210, 0},

    {210, 0, 0}, {210, 210, 0}, {210, 0, 210}, {210, 112, 0},

    {0, 210, 210}, {210, 210, 210}, {0, 0, 210}, {0, 210, 0},

    {210, 0, 0}, {210, 210, 0}, {210, 0, 210}, {210, 112, 0},

    {0, 195, 195}, {195, 195, 195}, {0, 0, 195}, {0, 195, 0},

    {195, 0, 0}, {195, 195, 0}, {195, 0, 195}, {195, 107, 0},

    {0, 195, 195}, {195, 195, 195}, {0, 0, 195}, {0, 195, 0},

    {195, 0, 0}, {195, 195, 0}, {195, 0, 195}, {195, 107, 0},

    {0, 180, 180}, {180, 180, 180}, {0, 0, 180}, {0, 180, 0},

    {180, 0, 0}, {180, 180, 0}, {180, 0, 180}, {180, 102, 0},

    {0, 180, 180}, {180, 180, 180}, {0, 0, 180}, {0, 180, 0},

    {180, 0, 0}, {180, 180, 0}, {180, 0, 180}, {180, 102, 0},

    {0, 165, 165}, {165, 165, 165}, {0, 0, 165}, {0, 165, 0},

    {165, 0, 0}, {165, 165, 0}, {165, 0, 165}, {165, 97, 0},

    {0, 165, 165}, {165, 165, 165}, {0, 0, 165}, {0, 165, 0},

    {165, 0, 0}, {165, 165, 0}, {165, 0, 165}, {165, 97, 0},

    {0, 150, 150}, {150, 150, 150}, {0, 0, 150}, {0, 150, 0},

    {150, 0, 0}, {150, 150, 0}, {150, 0, 150}, {150, 92, 0},

    {0, 150, 150}, {150, 150, 150}, {0, 0, 150}, {0, 150, 0},

    {150, 0, 0}, {150, 150, 0}, {150, 0, 150}, {150, 92, 0},

    {0, 135, 135}, {135, 135, 135}, {0, 0, 135}, {0, 135, 0},

    {135, 0, 0}, {135, 135, 0}, {135, 0, 135}, {135, 87, 0},

    {0, 135, 135}, {135, 135, 135}, {0, 0, 135}, {0, 135, 0},

    {135, 0, 0}, {135, 135, 0}, {135, 0, 135}, {135, 87, 0},

    {0, 120, 120}, {120, 120, 120}, {0, 0, 120}, {0, 120, 0},

    {120, 0, 0}, {120, 120, 0}, {120, 0, 120}, {120, 82, 0},

    {0, 120, 120}, {120, 120, 120}, {0, 0, 120}, {0, 120, 0},

    {120, 0, 0}, {120, 120, 0}, {120, 0, 120}, {120, 82, 0},

    {0, 105, 105}, {105, 105, 105}, {0, 0, 105}, {0, 105, 0},

    {105, 0, 0}, {105, 105, 0}, {105, 0, 105}, {105, 77, 0},

    {0, 105, 105}, {105, 105, 105}, {0, 0, 105}, {0, 105, 0},

    {105, 0, 0}, {105, 105, 0}, {105, 0, 105}, {105, 77, 0},

    {0, 90, 90}, {90, 90, 90}, {0, 0, 90}, {0, 90, 0},

    {90, 0, 0}, {90, 90, 0}, {90, 0, 90}, {90, 72, 0},

    {0, 90, 90}, {90, 90, 90}, {0, 0, 90}, {0, 90, 0},

    {90, 0, 0}, {90, 90, 0}, {90, 0, 90}, {90, 72, 0},

    {0, 75, 75}, {75, 75, 75}, {0, 0, 75}, {0, 75, 0},

    {75, 0, 0}, {75, 75, 0}, {75, 0, 75}, {75, 67, 0},

    {0, 75, 75}, {75, 75, 75}, {0, 0, 75}, {0, 75, 0},

    {75, 0, 0}, {75, 75, 0}, {75, 0, 75}, {75, 67, 0},

    {0, 60, 60}, {60, 60, 60}, {0, 0, 60}, {0, 60, 0},

    {60, 0, 0}, {60, 60, 0}, {60, 0, 60}, {60, 62, 0},

    {0, 60, 60}, {60, 60, 60}, {0, 0, 60}, {0, 60, 0},

    {60, 0, 0}, {60, 60, 0}, {60, 0, 60}, {60, 62, 0},

    {0, 45, 45}, {45, 45, 45}, {0, 0, 45}, {0, 45, 0},

    {45, 0, 0}, {45, 45, 0}, {45, 0, 45}, {45, 57, 0},

    {0, 45, 45}, {45, 45, 45}, {0, 0, 45}, {0, 45, 0},

    {45, 0, 0}, {45, 45, 0}, {45, 0, 45}, {45, 57, 0},

    {0, 30, 30}, {30, 30, 30}, {0, 0, 30}, {0, 30, 0},

    {30, 0, 0}, {30, 30, 0}, {30, 0, 30}, {30, 52, 0},

    {0, 30, 30}, {30, 30, 30}, {0, 0, 30}, {0, 30, 0},

    {30, 0, 0}, {30, 30, 0}, {30, 0, 30}, {192, 192, 192},

    {28, 0, 100}};

    private int LSB;

    private FileInputStream fin;

    // private LEDataInputStream input;

    private MappedByteBuffer bb;

    private int FALSE = 0;

    private int TRUE = 1;

    private DGNElemCore elemento;

    private DGNInfo info; // Contiene el path y otras cosas

    private Rectangle2D.Double m_BoundingBox;

    private DGNElemColorTable m_colorTable;

    private boolean logErrors = false;

    public DGNReader(String pathFich) throws DataException {

        this(pathFich, false);

    }

    public DGNReader(String pathFich, boolean logErrors) throws DataException {

        this.logErrors = logErrors;

        info = new DGNInfo();

        DGNElemCore elemento = new DGNElemCore(this);

        int iArg;

        int bReportExtents = 0;

        byte[] achRaw = new byte[64];

        achRaw[63] = 1;

        double dfSFXMin = 0.0;

        double dfSFXMax = 0.0;

        double dfSFYMin = 0.0;

        double dfSFYMax = 0.0;

        info.fp = pathFich;

        info = DGNOpen(info, 0);

        bb.rewind();

        DGNSetSpatialFilter(info, dfSFXMin, dfSFYMin, dfSFXMax, dfSFYMax);

        int nLevel;

        int nType;

        int[] anLevelTypeCount = new int[128 * 64];

        int[] anLevelCount = new int[64];

        int[] anTypeCount = new int[128];

        double[] adfExtents = new double[6];

        int[] nCount = new int[1];

        nCount[0] = 0;

        DGNGetExtents(info, adfExtents); // extender

        logdebug("X Range:" + adfExtents[0] + ", " + adfExtents[3]);

        logdebug("Y Range:" + adfExtents[1] + ", " + adfExtents[4]);

        logdebug("Z Range:" + adfExtents[2] + ", " + adfExtents[5]);

        m_BoundingBox = new Rectangle2D.Double();

        m_BoundingBox.setRect(adfExtents[0], adfExtents[1],

                (adfExtents[3] - adfExtents[0]),

                (adfExtents[4] - adfExtents[1]));

        /* m_Renderer = new FRenderer(this); */

        DGNElementInfo[] pasEI; // =new DGNElementInfo[nCount+1];

        pasEI = DGNGetElementIndex(info, nCount);

        logdebug("Total Elements:" + nCount[0]);

        for (int i = 0; i < nCount[0]; i++) {

            anLevelTypeCount[(pasEI[i].level * 128) + pasEI[i].type]++;

            anLevelCount[pasEI[i].level]++;

            anTypeCount[pasEI[i].type]++;

        }

        logdebug("Per Type Report");

        logdebug("===============");

        for (nType = 0; nType < 128; nType++) {

            if (anTypeCount[nType] != 0) {

                logdebug("Type:" + DGNTypeToName(nType) + ":"

                        + anTypeCount[nType]);

            }

        }

        logdebug("Per Level Report\n");

        logdebug("================\n");

        for (nLevel = 0; nLevel < 64; nLevel++) {

            if (anLevelCount[nLevel] == 0) {

                continue;

            }

            logdebug("Level " + nLevel + "," + anLevelCount[nLevel] + "elements:");

            for (nType = 0; nType < 128; nType++) {

                if (anLevelTypeCount[(nLevel * 128) + nType] != 0) {

                    logdebug("  Type " + DGNTypeToName(nType)

                            + "," + anLevelTypeCount[(nLevel * 128) + nType]);

                }

            }

        }

        bb.rewind();

    }

    public boolean is3D() {

        return this.info.dimension==3;

    }

    /*

     * public Color getColor(int indexColor) { int r,g,b; //

     * System.err.println("indexcolor = " + indexColor); // Si no hay tabla de

     * colores, interpretamos que todas las cosas son negras if (m_colorTable ==

     * null) return new Color(0,0,0);

     * 

     * r = ByteUtils.getUnsigned(m_colorTable.color_info[indexColor][0]); g =

     * ByteUtils.getUnsigned(m_colorTable.color_info[indexColor][1]); b =

     * ByteUtils.getUnsigned(m_colorTable.color_info[indexColor][2]);

     * 

     * if ((r==255) && (g==255) & (b==255)) { r=g=b=0; // El color blanco lo

     * devolvemos como negro. }

     * 

     * return new Color(r,g,b); }

     */

    /**

     * Devuelve la informaci?n del DGN.

     *

     * @return DGNInfo Informaci?n.

     */

    public DGNInfo getInfo() {

        return info;

    }

    /**

     * Devuelve el n?mero de elementos.

     *

     * @return N?mero de elementos.

     */

    public int getNumEntities() {

        return info.element_count;

    }

    /**

     * Devuelve el rect?ngulo del extent.

     *

     * @return Rect?ngulo.

     */

    public Rectangle2D getBoundingBox() {

        return m_BoundingBox;

    }

    /**

     * *********************************************************************

     */

    /* DGNGotoElement() */

    /**

     * *********************************************************************

     */

    /**

     * Seek to indicated element. Changes what element will be read on the next

     * call to DGNReadElement(). Note that this function requires and index, and

     * one will be built if not already available.

     *

     * @param element_id the element to seek to. These values are sequentially

     * ordered starting at zero for the first element.

     *

     * @return returns TRUE on success or FALSE on failure.

     */

    public int DGNGotoElement(int element_id) {

        DGNBuildIndex(info);

        if ((element_id < 0) || (element_id >= info.element_count)) {

            return FALSE;

        }

        bb.position((int) info.element_index[element_id].offset);

        info.next_element_id = element_id;

        info.in_complex_group = FALSE;

        return TRUE;

    }

    private DGNInfo DGNOpen(DGNInfo info, int bUpdate) throws DataException {

        int pos = 0;

        byte[] abyHeader = new byte[512];

        info.next_element_id = 0;

        info.got_tcb = FALSE;

        info.scale = 1.0;

        info.origin_x = 0.0;

        info.origin_y = 0.0;

        info.origin_z = 0.0;

        info.index_built = FALSE;

        info.element_count = 0;

        info.element_index = null;

        info.got_bounds = FALSE;

        try {

            fin = new FileInputStream(info.fp);

            FileChannel fc = fin.getChannel();

            long sz = fc.size();

            int numReg;

            // Get the file's size and then map it into memory

            bb = fc.map(FileChannel.MapMode.READ_ONLY, 0, sz);

            bb.order(ByteOrder.nativeOrder());

            bb.get(abyHeader, pos, abyHeader.length);

            info.ftall = (int) (sz / 16);

            if (bb.order() == ByteOrder.LITTLE_ENDIAN) {

                LSB = TRUE;

            }

            if (DGNTestOpen(abyHeader, abyHeader.length) != FALSE) {

                if (abyHeader[0] == (byte) 0xC8) {

                    info.dimension = 3; // 0xC8

                } else {

                    info.dimension = 2;

                }

                info.has_spatial_filter = FALSE;

                info.sf_converted_to_uor = FALSE;

                info.select_complex_group = FALSE;

                info.in_complex_group = FALSE;

            }

        } catch (FileNotFoundException e) {

            throw new org.gvsig.fmap.dal.exception.FileNotFoundException(

                    info.fp);

        } catch (Exception e) {

            throw new ReadException("DGNReader error", e);

        }

        return info;

    }

    /**

     * Comprobaci?n si se puede abrir el fichero.

     *

     * @param pabyHeader Vector byte con el header.

     * @param nByteCount n?mero de bytes.

     *

     * @return Devuelve un enteor que muestra si no hay errores.

     */

    private int DGNTestOpen(byte[] pabyHeader, int nByteCount) {

        if (nByteCount < 4) {

            return TRUE;

        }

        // Is it a cell library?

        if ((pabyHeader[0] == (byte) 0x08) && (pabyHeader[1] == (byte) 0x05)

                && (pabyHeader[2] == (byte) 0x17)

                && (pabyHeader[3] == (byte) 0x00)) {

            return TRUE;

        }

        // Is it not a regular 2D or 3D file?

        if (((pabyHeader[0] != (byte) 0x08) && (pabyHeader[0] != (byte) 0xC8))

                || (pabyHeader[1] != (byte) 0x09)

                || (pabyHeader[2] != (byte) 0xFE)

                || (pabyHeader[3] != (byte) 0x02)) {

            return FALSE;

        }

        return TRUE;

    }

    /**

     * Lee una fila del elemento.

     *

     * @param info Informaci?n del DGN.

     * @param core Elemento.

     *

     * @return Devuelve un entero que muestra si se ha calculado correctamente.

     */

    private int DGNLoadRawElement(DGNInfo info, DGNElemCore core) {

        /* -------------------------------------------------------------------- */

        /* Read the first four bytes to get the level, type, and word */

        /* count. */

        /* -------------------------------------------------------------------- */

        // int nType, nWords, nLevel;

        int nType = 0;

        int nWords = 0;

        int nLevel = 0;

        int bytesCount = 0;

        try {

            // input=new LEDataInputStream(fin);

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

                info.abyElem[i] = bb.get();

                if (i == 1) {

                    if ((info.abyElem[0] == -1) && (info.abyElem[1] == -1)) {

                        return FALSE;

                    }

                }

                // info.temporal[i]=input.readByte();

            }

            nWords = ByteUtils.byteToUnsignedInt(info.abyElem[2])

                    + (ByteUtils.byteToUnsignedInt(info.abyElem[3]) * 256);

            nType = ByteUtils.byteToUnsignedInt(info.abyElem[1]) & 0x7f;

            nLevel = ByteUtils.byteToUnsignedInt(info.abyElem[0]) & 0x3f;

            /*

             * ------------------------------------------------------------------

             */

            /* Read the rest of the element data into the working buffer. */

            if (((nWords * 2) + 4) > info.abyElem.length) {

                return FALSE;

            }

            for (; bytesCount < (nWords * 2) && bb.hasRemaining(); bytesCount++) {

                info.abyElem[bytesCount + 4] = bb.get();

            }

            info.ftall = bb.position();

        } catch (Exception e) {

            logwarn(MessageFormat.format("The DGN file {0} may not be loaded correctly.\n"

                    + "Error loading:\n"

                    + "nWords = {1}\n"

                    + "info.next_element_id {2}\n"

                    + "info.abyElem.length =  {3}\n"

                    + "bb.position() =  {4}",

                    info.fp,

                    nWords,

                    info.next_element_id,

                    info.abyElem.length,

                    bb.position()), e);

            return FALSE;

        }

        info.nElemBytes = bytesCount + 4;

        info.next_element_id++;

        /* -------------------------------------------------------------------- */

        /* Return requested info. */

        /* -------------------------------------------------------------------- */

        core.type = nType;

        core.level = nLevel;

        return TRUE;

    }

    /**

     * Calcula el filtro espacial al rect?ngulo del elemento.

     *

     * @param info Informaci?n del DGN.

     */

    private void DGNSpatialFilterToUOR(DGNInfo info) {

        DGNPoint sMin = new DGNPoint();

        DGNPoint sMax = new DGNPoint();

        if ((info.sf_converted_to_uor == 1)

                || (!(info.has_spatial_filter == 1)) || (!(info.got_tcb == 1))) {

            return;

        }

        sMin.x = info.sf_min_x_geo;

        sMin.y = info.sf_min_y_geo;

        sMin.z = 0;

        sMax.x = info.sf_max_x_geo;

        sMax.y = info.sf_max_y_geo;

        sMax.z = 0;

        DGNInverseTransformPoint(info, sMin);

        DGNInverseTransformPoint(info, sMax);

        info.sf_min_x = (long) (sMin.x + 2147483648.0);

        info.sf_min_y = (long) (sMin.y + 2147483648.0);

        info.sf_max_x = (long) (sMax.x + 2147483648.0);

        info.sf_max_y = (long) (sMax.y + 2147483648.0);

        info.sf_converted_to_uor = TRUE;

    }

    /**

     * Calcula un punto aplicandole la transformaci?n.

     *

     * @param info Informaci?n del DGN.

     * @param punto Punto.

     */

    private void DGNInverseTransformPoint(DGNInfo info, DGNPoint punto) {

        punto.x = (punto.x + info.origin_x) / info.scale;

        punto.y = (punto.y + info.origin_y) / info.scale;

        punto.z = (punto.z + info.origin_z) / info.scale;

        punto.x = Math.max(-2147483647, Math.min(2147483647, punto.x));

        punto.y = Math.max(-2147483647, Math.min(2147483647, punto.y));

        punto.z = Math.max(-2147483647, Math.min(2147483647, punto.z));

    }

    public DGNElemCore DGNReadElement() {

        DGNElemCore elemento = new DGNElemCore(this);

        int nType;

        int nLevel;

        int bInsideFilter;

        /* -------------------------------------------------------------------- */

        /* Load the element data into the current buffer. If a spatial */

        /* filter is in effect, loop until we get something within our */

        /* spatial constraints. */

        /* -------------------------------------------------------------------- */

        do {

            bInsideFilter = TRUE;

            int fin_fichero = DGNLoadRawElement(info, elemento);

            if (fin_fichero == FALSE) {

                return null;

            }

            if (info.has_spatial_filter != FALSE) {

                if (info.sf_converted_to_uor == FALSE) {

                    DGNSpatialFilterToUOR(info);

                }

                if (DGNGetRawExtents(info, null, elemento) == null) {

                    bInsideFilter = TRUE;

                } else if ((info.min_x > info.sf_max_x)

                        || (info.min_y > info.sf_max_y)

                        || (info.max_x < info.sf_min_x)

                        || (info.max_y < info.sf_min_y)) {

                    bInsideFilter = FALSE;

                }

                if ((elemento.type == DGNFileHeader.DGNT_COMPLEX_CHAIN_HEADER)

                        || (elemento.type == DGNFileHeader.DGNT_COMPLEX_SHAPE_HEADER)) {

                    info.in_complex_group = TRUE;

                    info.select_complex_group = bInsideFilter;

                } else if ((info.abyElem[0] & (byte) 0x80) != FALSE) {

                    if (info.in_complex_group == TRUE) {

                        bInsideFilter = info.select_complex_group;

                    }

                } else {

                    info.in_complex_group = FALSE;

                }

            }

        } while (bInsideFilter == FALSE);

        elemento = DGNProcessElement(info, elemento.type, elemento.level);

        return elemento;

    }

    /**

     * Devuelve los extent de una fila.

     *

     * @param info Informaci?n del DGN.

     * @param pabyRawData Vector de byte.

     * @param elemento Elemento.

     *

     * @return Vector de double.

     */

    public double[] DGNGetRawExtents(DGNInfo info, byte[] pabyRawData,

            DGNElemCore elemento) {

        if (pabyRawData == null) {

            pabyRawData = info.abyElem;

        }

        double[] tempo = new double[6];

        switch (elemento.type) {

            case DGNFileHeader.DGNT_LINE:

            case DGNFileHeader.DGNT_LINE_STRING:

            case DGNFileHeader.DGNT_SHAPE:

            case DGNFileHeader.DGNT_CURVE:

            case DGNFileHeader.DGNT_BSPLINE:

            case DGNFileHeader.DGNT_ELLIPSE:

            case DGNFileHeader.DGNT_ARC:

            case DGNFileHeader.DGNT_TEXT:

            case DGNFileHeader.DGNT_COMPLEX_CHAIN_HEADER:

            case DGNFileHeader.DGNT_COMPLEX_SHAPE_HEADER:

                byte[] temp = new byte[4];

                System.arraycopy(pabyRawData, 4, temp, 0, 4);

                tempo[0] = DGN_INT32(temp); // 4

                System.arraycopy(pabyRawData, 8, temp, 0, 4);

                tempo[1] = DGN_INT32(temp);

                System.arraycopy(pabyRawData, 12, temp, 0, 4);

                tempo[2] = DGN_INT32(temp);

                System.arraycopy(pabyRawData, 16, temp, 0, 4);

                tempo[3] = DGN_INT32(temp);

                System.arraycopy(pabyRawData, 20, temp, 0, 4);

                tempo[4] = DGN_INT32(temp);

                System.arraycopy(pabyRawData, 24, temp, 0, 4);

                tempo[5] = DGN_INT32(temp);

                return tempo;

            default:

                return null;

        }

    }

    /**

     * A partir de un vector de byte devuelve un double.

     *

     * @param p Vector de byte.

     *

     * @return double.

     */

    private double DGN_INT32(byte[] p) {

        int x = 256;

        int x0;

        int x1;

        int x2;

        int x3;

        x0 = p[0];

        x1 = p[1];

        x2 = p[2];

        x3 = p[3];

        if (p[0] < 0) {

            x0 = x + p[0];

        }

        if (p[1] < 0) {

            x1 = x + p[1];

        }

        if (p[2] < 0) {

            x2 = x + p[2];

        }

        if (p[3] < 0) {

            x3 = x + p[3];

        }

        return (x2 + (x3 * 256) + (x1 * 65536 * 256) + (x0 * 65536));

    }

    private DGNElemCore DGNProcessElement(DGNInfo info, int nType, int nLevel) {

        DGNElemCore elemento = new DGNElemCore(this);

        switch (nType) {

            case DGNFileHeader.DGNT_SHARED_CELL_DEFN:

                logdebug("DGNProcessElement (DGNT_SHARED_CELL_DEFN): Type " + DGNTypeToName(nType));

                elemento.stype = DGNFileHeader.DGNST_SHARED_CELL_DEFN;

                DGNParseCore(info, elemento);

                break;

            case DGNFileHeader.DGNT_CELL_HEADER: {

                DGNElemCellHeader psCell = new DGNElemCellHeader(this);

                psCell.stype = DGNFileHeader.DGNST_CELL_HEADER;

                DGNParseCore(info, psCell);

                psCell.totlength = ByteUtils.getUnsigned(info.abyElem[36])

                        + (ByteUtils.getUnsigned(info.abyElem[37]) * 256);

                byte[] temp = new byte[psCell.name.length];

                System.arraycopy(psCell.name, 0, temp, 0, psCell.name.length);

                DGNRad50ToAscii(ByteUtils.byteToUnsignedInt(info.abyElem[38])

                        + (ByteUtils.byteToUnsignedInt(info.abyElem[39]) * 256),

                        temp);

                System.arraycopy(psCell.name, 3, temp, 0, psCell.name.length - 3);

                DGNRad50ToAscii(ByteUtils.byteToUnsignedInt(info.abyElem[40])

                        + (ByteUtils.byteToUnsignedInt(info.abyElem[41]) * 256),

                        temp);

                psCell.cclass = ByteUtils.byteToUnsignedInt(info.abyElem[42])

                        + (ByteUtils.byteToUnsignedInt(info.abyElem[43]) * 256);

                psCell.levels[0] = ByteUtils.byteToUnsignedInt(info.abyElem[44])

                        + (ByteUtils.byteToUnsignedInt(info.abyElem[45]) * 256);

                psCell.levels[1] = ByteUtils.byteToUnsignedInt(info.abyElem[46])

                        + (ByteUtils.byteToUnsignedInt(info.abyElem[47]) * 256);

                psCell.levels[2] = ByteUtils.byteToUnsignedInt(info.abyElem[48])

                        + (ByteUtils.byteToUnsignedInt(info.abyElem[49]) * 256);

                psCell.levels[3] = ByteUtils.byteToUnsignedInt(info.abyElem[50])

                        + (ByteUtils.byteToUnsignedInt(info.abyElem[51]) * 256);

                psCell.color = info.abyElem[35];

                if (info.dimension == 2) {

                    byte[] temp1 = new byte[4];

                    System.arraycopy(info.abyElem, 52, temp1, 0, 4);

                    psCell.rnglow.x = DGN_INT32(temp1);

                    System.arraycopy(info.abyElem, 56, temp1, 0, 4);

                    psCell.rnglow.y = DGN_INT32(temp);

                    System.arraycopy(info.abyElem, 60, temp1, 0, 4);

                    psCell.rnghigh.x = DGN_INT32(temp1);

                    System.arraycopy(info.abyElem, 64, temp1, 0, 4);

                    psCell.rnghigh.y = DGN_INT32(temp1);

                    System.arraycopy(info.abyElem, 84, temp1, 0, 4);

                    psCell.origin.x = DGN_INT32(temp1);

                    System.arraycopy(info.abyElem, 88, temp1, 0, 4);

                    psCell.origin.y = DGN_INT32(temp1);

                    {

                        double a;

                        double b;

                        double c;

                        double d;

                        double a2;

                        double c2;

                        System.arraycopy(info.abyElem, 68, temp1, 0, 4);

                        a = DGN_INT32(temp1);

                        System.arraycopy(info.abyElem, 72, temp1, 0, 4);

                        b = DGN_INT32(temp1);

                        System.arraycopy(info.abyElem, 76, temp1, 0, 4);

                        c = DGN_INT32(temp1);

                        System.arraycopy(info.abyElem, 80, temp1, 0, 4);

                        d = DGN_INT32(temp1);

                        a2 = a * a;

                        c2 = c * c;

                        psCell.xscale = Math.sqrt(a2 + c2) / 214748;

                        psCell.yscale = Math.sqrt((b * b) + (d * d)) / 214748;

                        psCell.rotation = Math.acos(a / Math.sqrt(a2 + c2));

                        if (b <= 0) {

                            psCell.rotation = (psCell.rotation * 180) / Math.PI;

                        } else {

                            psCell.rotation = 360 - ((psCell.rotation * 180) / Math.PI);

                        }

                    }

                } else {

                    byte[] temp1 = new byte[4];

                    System.arraycopy(info.abyElem, 52, temp1, 0, 4);

                    psCell.rnglow.x = DGN_INT32(temp1);

                    System.arraycopy(info.abyElem, 56, temp1, 0, 4);

                    psCell.rnglow.y = DGN_INT32(temp1);

                    System.arraycopy(info.abyElem, 60, temp1, 0, 4);

                    psCell.rnglow.z = DGN_INT32(temp1);

                    System.arraycopy(info.abyElem, 64, temp1, 0, 4);

                    psCell.rnghigh.x = DGN_INT32(temp1);

                    System.arraycopy(info.abyElem, 68, temp1, 0, 4);

                    psCell.rnghigh.y = DGN_INT32(temp1);

                    System.arraycopy(info.abyElem, 72, temp1, 0, 4);

                    psCell.rnghigh.z = DGN_INT32(temp1);

                    System.arraycopy(info.abyElem, 112, temp1, 0, 4);

                    psCell.origin.x = DGN_INT32(temp1);

                    System.arraycopy(info.abyElem, 116, temp1, 0, 4);

                    psCell.origin.y = DGN_INT32(temp1);

                    System.arraycopy(info.abyElem, 120, temp1, 0, 4);

                    psCell.origin.z = DGN_INT32(temp1);

                }

                DGNTransformPoint(info, psCell.rnglow);

                DGNTransformPoint(info, psCell.rnghigh);

                DGNTransformPoint(info, psCell.origin);

                elemento = psCell;

            }

            break;

            case DGNFileHeader.DGNT_CELL_LIBRARY: {

                logdebug("DGNProcessElement (DGNT_CELL_LIBRARY): Type " + DGNTypeToName(nType));

                DGNElemCellLibrary psCell = new DGNElemCellLibrary(this);

                int iWord;

                psCell.stype = DGNFileHeader.DGNST_CELL_LIBRARY;

                DGNParseCore(info, psCell);

                byte[] temp = new byte[psCell.name.length];

                System.arraycopy(psCell.name, 0, temp, 0, psCell.name.length);

                DGNRad50ToAscii(ByteUtils.byteToUnsignedInt(info.abyElem[32])

                        + (ByteUtils.byteToUnsignedInt(info.abyElem[33]) * 256),

                        temp);

                System.arraycopy(psCell.name, 3, temp, 0, psCell.name.length);

                DGNRad50ToAscii(ByteUtils.byteToUnsignedInt(info.abyElem[34])

                        + (ByteUtils.byteToUnsignedInt(info.abyElem[35]) * 256),

                        temp);

                psCell.properties = info.abyElem[38] + (info.abyElem[39] * 256);

                psCell.dispsymb = ByteUtils.byteToUnsignedInt(info.abyElem[40])

                        + (ByteUtils.byteToUnsignedInt(info.abyElem[41]) * 256);

                psCell.cclass = ByteUtils.byteToUnsignedInt(info.abyElem[42])

                        + (ByteUtils.byteToUnsignedInt(info.abyElem[43]) * 256);

                psCell.levels[0] = ByteUtils.byteToUnsignedInt(info.abyElem[44])

                        + (ByteUtils.byteToUnsignedInt(info.abyElem[45]) * 256);

                psCell.levels[1] = ByteUtils.byteToUnsignedInt(info.abyElem[46])

                        + (ByteUtils.byteToUnsignedInt(info.abyElem[47]) * 256);

                psCell.levels[2] = ByteUtils.byteToUnsignedInt(info.abyElem[48])

                        + (ByteUtils.byteToUnsignedInt(info.abyElem[49]) * 256);

                psCell.levels[3] = ByteUtils.byteToUnsignedInt(info.abyElem[50])

                        + (ByteUtils.byteToUnsignedInt(info.abyElem[51]) * 256);

                psCell.numwords = ByteUtils.byteToUnsignedInt(info.abyElem[36])

                        + (ByteUtils.byteToUnsignedInt(info.abyElem[37]) * 256);

                for (iWord = 0; iWord < 9; iWord++) {

                    int iOffset = 52 + (iWord * 2);

                    System.arraycopy(psCell.name, iWord * 3, temp, 0,

                            psCell.description.length);

                    DGNRad50ToAscii(

                            ByteUtils.byteToUnsignedInt(info.abyElem[iOffset])

                            + (ByteUtils

                            .byteToUnsignedInt(info.abyElem[iOffset + 1]) * 256),

                            temp);

                }

                elemento = psCell;

            }

            break;

            case DGNFileHeader.DGNT_LINE: {

                DGNElemMultiPoint psLine = new DGNElemMultiPoint(this);

                psLine.stype = DGNFileHeader.DGNST_MULTIPOINT;

                DGNParseCore(info, psLine);

                psLine.num_vertices = 2;

                psLine.vertices = new DGNPoint[psLine.num_vertices];

                if (info.dimension == 2) {

                    byte[] temp1 = new byte[4];

                    System.arraycopy(info.abyElem, 36, temp1, 0, 4);

                    psLine.vertices[0] = new DGNPoint();

                    psLine.vertices[0].x = DGN_INT32(temp1);

                    System.arraycopy(info.abyElem, 40, temp1, 0, 4);

                    psLine.vertices[0].y = DGN_INT32(temp1);

                    System.arraycopy(info.abyElem, 44, temp1, 0, 4);

                    psLine.vertices[1] = new DGNPoint();

                    psLine.vertices[1].x = DGN_INT32(temp1);

                    System.arraycopy(info.abyElem, 48, temp1, 0, 4);

                    psLine.vertices[1].y = DGN_INT32(temp1);

                } else {

                    byte[] temp1 = new byte[4];

                    System.arraycopy(info.abyElem, 36, temp1, 0, 4);

                    psLine.vertices[0] = new DGNPoint();

                    psLine.vertices[0].x = DGN_INT32(temp1);

                    System.arraycopy(info.abyElem, 40, temp1, 0, 4);

                    psLine.vertices[0].y = DGN_INT32(temp1);

                    System.arraycopy(info.abyElem, 44, temp1, 0, 4);

                    psLine.vertices[0].z = DGN_INT32(temp1);

                    System.arraycopy(info.abyElem, 48, temp1, 0, 4);

                    psLine.vertices[1] = new DGNPoint();

                    psLine.vertices[1].x = DGN_INT32(temp1);

                    System.arraycopy(info.abyElem, 52, temp1, 0, 4);

                    psLine.vertices[1].y = DGN_INT32(temp1);

                    System.arraycopy(info.abyElem, 56, temp1, 0, 4);

                    psLine.vertices[1].z = DGN_INT32(temp1);

                }

                DGNTransformPoint(info, psLine.vertices[0]);

                DGNTransformPoint(info, psLine.vertices[1]);

                elemento = psLine;

            }

            break;

            case DGNFileHeader.DGNT_LINE_STRING:

            case DGNFileHeader.DGNT_SHAPE: // regular

            case DGNFileHeader.DGNT_CURVE: // mal

            case DGNFileHeader.DGNT_BSPLINE: // aceptable

            {

                DGNElemMultiPoint psLine = new DGNElemMultiPoint(this);

                int i;

                int count;

                int pntsize = info.dimension * 4;

                count = ByteUtils.byteToUnsignedInt(info.abyElem[36])

                        + (ByteUtils.byteToUnsignedInt(info.abyElem[37]) * 256);

                psLine.stype = DGNFileHeader.DGNST_MULTIPOINT;

                DGNParseCore(info, psLine);

                if (info.nElemBytes < (38 + (count * pntsize))) {

                    logdebug("Error en los vertices de multipunto");

                    count = (info.nElemBytes - 38) / pntsize;

                    return null;

                }

                psLine.num_vertices = count;

                psLine.vertices = new DGNPoint[psLine.num_vertices];

                for (i = 0; i < psLine.num_vertices; i++) {

                    byte[] temp1 = new byte[4];

                    System.arraycopy(info.abyElem, 38 + (i * pntsize), temp1, 0, 4);

                    psLine.vertices[i] = new DGNPoint();

                    psLine.vertices[i].x = DGN_INT32(temp1);

                    System.arraycopy(info.abyElem, 42 + (i * pntsize), temp1, 0, 4);

                    psLine.vertices[i].y = DGN_INT32(temp1);

                    if (info.dimension == 3) {

                        System.arraycopy(info.abyElem, 46 + (i * pntsize), temp1,

                                0, 4);

                        psLine.vertices[i].z = DGN_INT32(temp1);

                    }

                    DGNTransformPoint(info, psLine.vertices[i]);

                }

                elemento = psLine;

            }

            break;

            case DGNFileHeader.DGNT_GROUP_DATA:

                if (nLevel == DGNFileHeader.DGN_GDL_COLOR_TABLE) {

                    elemento = DGNParseColorTable(info);

                } else {

                    elemento.stype = DGNFileHeader.DGNST_CORE;

                    DGNParseCore(info, elemento);

                }

                break;

            case DGNFileHeader.DGNT_ELLIPSE: {

                DGNElemArc psEllipse = new DGNElemArc(this);

                psEllipse.stype = DGNFileHeader.DGNST_ARC;

                DGNParseCore(info, psEllipse);

                int[] fin = new int[1];

                fin[0] = 0;

                byte[] temp1 = new byte[8];

                System.arraycopy(info.abyElem, 36, temp1, 0, 8);

                fin[0] = 0;

                psEllipse.primary_axis = DGNParseIEEE(temp1);

                psEllipse.primary_axis *= info.scale;

                System.arraycopy(info.abyElem, 44, temp1, 0, 8);

                fin[0] = 0;

                psEllipse.secondary_axis = DGNParseIEEE(temp1);

                psEllipse.secondary_axis *= info.scale;

                if (info.dimension == 2) {

                    System.arraycopy(info.abyElem, 52, temp1, 0, 4);

                    psEllipse.rotation = DGN_INT32(temp1);

                    psEllipse.rotation = psEllipse.rotation / 360000.0;

                    System.arraycopy(info.abyElem, 56, temp1, 0, 8);

                    fin[0] = 0;

                    psEllipse.origin.x = DGNParseIEEE(temp1);

                    System.arraycopy(info.abyElem, 64, temp1, 0, 8);

                    fin[0] = 0;

                    psEllipse.origin.y = DGNParseIEEE(temp1);

                } else {

                    // leave quaternion for later

                    System.arraycopy(info.abyElem, 68, temp1, 0, 8);

                    fin[0] = 0;

                    psEllipse.origin.x = DGNParseIEEE(temp1);

                    System.arraycopy(info.abyElem, 76, temp1, 0, 8);

                    fin[0] = 0;

                    psEllipse.origin.y = DGNParseIEEE(temp1);

                    System.arraycopy(info.abyElem, 84, temp1, 0, 8);

                    fin[0] = 0;

                    psEllipse.origin.z = DGNParseIEEE(temp1);

                    System.arraycopy(info.abyElem, 52, temp1, 0, 4);

                    psEllipse.quat[0] = DGN_INT32(temp1);

                    System.arraycopy(info.abyElem, 56, temp1, 0, 4);

                    psEllipse.quat[1] = DGN_INT32(temp1);

                    System.arraycopy(info.abyElem, 60, temp1, 0, 4);

                    psEllipse.quat[2] = DGN_INT32(temp1);

                    System.arraycopy(info.abyElem, 64, temp1, 0, 4);

                    psEllipse.quat[3] = DGN_INT32(temp1);

                }

                DGNTransformPoint(info, (psEllipse.origin));

                psEllipse.startang = 0.0;

                psEllipse.sweepang = 360.0;

                elemento = psEllipse;

            }

            break;

            case DGNFileHeader.DGNT_ARC: {

                DGNElemArc psEllipse = new DGNElemArc(this);

                double nSweepVal;

                psEllipse.stype = DGNFileHeader.DGNST_ARC;

                DGNParseCore(info, psEllipse);

                int[] fin = new int[1];

                fin[0] = 0;

                byte[] temp1 = new byte[8];

                System.arraycopy(info.abyElem, 36, temp1, 0, 4);

                psEllipse.startang = DGN_INT32(temp1);

                psEllipse.startang = psEllipse.startang / 360000.0;

                if ((info.abyElem[41] & (byte) 0x80) != FALSE) {

                    info.abyElem[41] &= (byte) 0x7f;

                    System.arraycopy(info.abyElem, 40, temp1, 0, 4);

                    nSweepVal = -1 * DGN_INT32(temp1);

                } else {

                    System.arraycopy(info.abyElem, 40, temp1, 0, 4);

                    nSweepVal = DGN_INT32(temp1);

                }

                if (nSweepVal == 0) {

                    psEllipse.sweepang = 360.0;

                } else {

                    psEllipse.sweepang = nSweepVal / 360000.0;

                }

                System.arraycopy(info.abyElem, 44, temp1, 0, 8);

                fin[0] = 0;

                psEllipse.primary_axis = DGNParseIEEE(temp1);

                psEllipse.primary_axis *= info.scale;

                System.arraycopy(info.abyElem, 52, temp1, 0, 8);

                fin[0] = 0;

                psEllipse.secondary_axis = DGNParseIEEE(temp1);

                psEllipse.secondary_axis *= info.scale;

                if (info.dimension == 2) {

                    System.arraycopy(info.abyElem, 60, temp1, 0, 4);

                    psEllipse.rotation = DGN_INT32(temp1);

                    psEllipse.rotation = psEllipse.rotation / 360000.0;

                    System.arraycopy(info.abyElem, 64, temp1, 0, 8);

                    fin[0] = 0;

                    psEllipse.origin.x = DGNParseIEEE(temp1);

                    System.arraycopy(info.abyElem, 72, temp1, 0, 8);

                    fin[0] = 0;

                    psEllipse.origin.y = DGNParseIEEE(temp1);

                } else {

                    // for now we don't try to handle quaternion

                    psEllipse.rotation = 0;

                    System.arraycopy(info.abyElem, 76, temp1, 0, 8);

                    fin[0] = 0;

                    psEllipse.origin.x = DGNParseIEEE(temp1);

                    System.arraycopy(info.abyElem, 84, temp1, 0, 8);

                    fin[0] = 0;

                    psEllipse.origin.y = DGNParseIEEE(temp1);

                    System.arraycopy(info.abyElem, 92, temp1, 0, 8);

                    fin[0] = 0;

                    psEllipse.origin.z = DGNParseIEEE(temp1);

                    System.arraycopy(info.abyElem, 60, temp1, 0, 4);

                    psEllipse.quat[0] = DGN_INT32(temp1);

                    System.arraycopy(info.abyElem, 64, temp1, 0, 4);

                    psEllipse.quat[1] = DGN_INT32(temp1);

                    System.arraycopy(info.abyElem, 68, temp1, 0, 4);

                    psEllipse.quat[2] = DGN_INT32(temp1);

                    System.arraycopy(info.abyElem, 72, temp1, 0, 4);

                    psEllipse.quat[3] = DGN_INT32(temp1);

                }

                DGNTransformPoint(info, (psEllipse.origin));

                elemento = psEllipse;

            }

            break;

            case DGNFileHeader.DGNT_TEXT: {

                DGNElemText psText = new DGNElemText(this);

                int num_chars;

                int text_off;

                if (info.dimension == 2) {

                    num_chars = ByteUtils.byteToUnsignedInt(info.abyElem[58]);

                } else {

                    num_chars = ByteUtils.byteToUnsignedInt(info.abyElem[74]);

                }

                psText.stype = DGNFileHeader.DGNST_TEXT;

                DGNParseCore(info, psText);

                psText.font_id = ByteUtils.byteToUnsignedInt(info.abyElem[36]);

                psText.justification = ByteUtils

                        .byteToUnsignedInt(info.abyElem[37]);

                byte[] temp1 = new byte[8];

                System.arraycopy(info.abyElem, 38, temp1, 0, 4);

                psText.length_mult = (DGN_INT32(temp1) * info.scale * 6.0) / 1000.0;

                System.arraycopy(info.abyElem, 42, temp1, 0, 4);

                psText.height_raw = DGN_INT32(temp1) ;

                psText.height_mult = (psText.height_raw * info.scale * 6.0) / 1000.0;

                int[] fin = new int[1];

                fin[0] = 0;

                if (info.dimension == 2) {

                    System.arraycopy(info.abyElem, 46, temp1, 0, 4);

                    psText.rotation = DGN_INT32(temp1);

                    psText.rotation = psText.rotation / 360000.0;

                    System.arraycopy(info.abyElem, 50, temp1, 0, 4);

                    psText.origin.x = DGN_INT32(temp1);

                    System.arraycopy(info.abyElem, 54, temp1, 0, 4);

                    psText.origin.y = DGN_INT32(temp1);

                    text_off = 60;

                } else {

                    /* leave quaternion for later */

                    System.arraycopy(info.abyElem, 62, temp1, 0, 4);

                    psText.origin.x = DGN_INT32(temp1);

                    System.arraycopy(info.abyElem, 66, temp1, 0, 4);

                    psText.origin.y = DGN_INT32(temp1);

                    System.arraycopy(info.abyElem, 70, temp1, 0, 4);

                    psText.origin.z = DGN_INT32(temp1);

                    text_off = 76;

                }

                DGNTransformPoint(info, (psText.origin));

                // TODO: AQUI FALTA METER ALGO PARA SOPORTAR TEXTOS MULTYBYTE

                byte[] temp = new byte[num_chars];

                System.arraycopy(info.abyElem, text_off, temp, 0, num_chars);

                String strAux = null;

                try {

                    psText.string = new String(temp, "ISO-8859-1");

                } catch (Exception e) {

                    logwarn("Can't create java string from byte array (" + dumpBuffer(temp) + ").", e);

                }

                elemento = psText;

            }

            break;

            case DGNFileHeader.DGNT_TCB:

                if (info.got_tcb == FALSE) {

                    elemento = DGNParseTCB(info);

                    elemento.level = nLevel;

                    elemento.type = nType;

                }

                break;

            case DGNFileHeader.DGNT_COMPLEX_CHAIN_HEADER:

            case DGNFileHeader.DGNT_COMPLEX_SHAPE_HEADER: {

                DGNElemComplexHeader psHdr = new DGNElemComplexHeader(this);

                psHdr.stype = DGNFileHeader.DGNST_COMPLEX_HEADER;

                DGNParseCore(info, psHdr);

                psHdr.totlength = ByteUtils.byteToUnsignedInt(info.abyElem[36])

                        + (ByteUtils.byteToUnsignedInt(info.abyElem[37]) * 256);

                psHdr.numelems = ByteUtils.byteToUnsignedInt(info.abyElem[38])

                        + (ByteUtils.byteToUnsignedInt(info.abyElem[39]) * 256);

                elemento = psHdr;

            }

            break;

            case DGNFileHeader.DGNT_TAG_VALUE: {

                DGNElemTagValue psTag = new DGNElemTagValue(this);

                psTag.stype = DGNFileHeader.DGNST_TAG_VALUE;

                DGNParseCore(info, psTag);

                int[] fin = new int[1];

                fin[0] = 0;

                byte[] temp1 = new byte[8];

                psTag.tagType = ByteUtils.byteToUnsignedInt(info.abyElem[74])

                        + (ByteUtils.byteToUnsignedInt(info.abyElem[75]) * 256);

                System.arraycopy(info.abyElem, 68, temp1, 0, 4);

                fin[0] = 0;

                psTag.tagSet = ByteUtils.bytesToInt(temp1, fin);

                psTag.tagSet = CPL_LSBWORD32(psTag.tagSet);

                psTag.tagIndex = ByteUtils.byteToUnsignedInt(info.abyElem[72])

                        + (ByteUtils.byteToUnsignedInt(info.abyElem[73]) * 256);

                psTag.tagLength = ByteUtils.byteToUnsignedInt(info.abyElem[150])

                        + (ByteUtils.byteToUnsignedInt(info.abyElem[151]) * 256);

                if (psTag.tagType == 1) {

                    byte[] temp = new byte[info.abyElem.length - 154];

                    System.arraycopy(info.abyElem, 4, temp1, 0, // 154

                            4); // info.abyElem.length - 154

                    fin[0] = 0;

                    psTag.tagValue.string = ByteUtils.bytesToString(temp1, fin).toCharArray();

                } else if (psTag.tagType == 3) {

                    byte[] temp = new byte[4];

                    System.arraycopy(info.abyElem, 154, temp1, 0, 4);

                    fin[0] = 0;

                    psTag.tagValue.integer = ByteUtils.bytesToInt(temp1, fin);

                    psTag.tagValue.integer = CPL_LSBWORD32((int) psTag.tagValue.integer);

                } else if (psTag.tagType == 4) {

                    byte[] temp = new byte[8];

                    System.arraycopy(info.abyElem, 154, temp1, 0, 8);

                    fin[0] = 0;

                    psTag.tagValue.real = DGNParseIEEE(temp1);

                }

                elemento = psTag;

            }

            break;

            default: {

                elemento.stype = DGNFileHeader.DGNST_CORE;

                DGNParseCore(info, elemento);

            }

            break;

        }

        /* -------------------------------------------------------------------- */

        /* If the element structure type is "core" or if we are running */

        /* in "capture all" mode, record the complete binary image of */

        /* the element. */

        /* -------------------------------------------------------------------- */

        if ((elemento.stype == DGNFileHeader.DGNST_CORE)

                || ((info.options & DGNFileHeader.DGNO_CAPTURE_RAW_DATA) != FALSE)) {

            elemento.raw_bytes = info.nElemBytes;

            elemento.raw_data = new byte[elemento.raw_bytes];

            int[] fin = new int[1];

            fin[0] = 0;

            System.arraycopy(info.abyElem, 0, elemento.raw_data, 0,

                    elemento.raw_bytes);

        }

        /* -------------------------------------------------------------------- */

        /* Collect some additional generic information. */

        /* -------------------------------------------------------------------- */

        elemento.element_id = info.next_element_id - 1;

        elemento.offset = info.ftall - info.nElemBytes;

        elemento.size = info.nElemBytes;

        return elemento;

    }

    private String numberFormat(String fmt, byte number) {

        Formatter out = new Formatter();

        return out.format(fmt, number).toString();

    }

    private String numberFormat(String fmt, int number) {

        Formatter out = new Formatter();

        return out.format(fmt, number).toString();

    }

    private String numberFormat(String fmt, double number) {

        Formatter out = new Formatter();

        return out.format(fmt, number).toString();

    }

    private String dumpBuffer(byte[] buffer) {

        StringBuffer out = new StringBuffer();

        StringBuffer out1 = new StringBuffer();

        Formatter out2 = new Formatter();

        int n = 0;

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

            int ch = buffer[i] & 0xff;

            if (Character.isLetterOrDigit(ch)) {

                out1.append(Character.valueOf((char) ch));

            } else {

                out1.append("-");

            }

            out2.format("0x%02X ", ch);

            if (++n >= 8) {

                n = 0;

                out.append(out1);

                out.append("|");

                out.append(out2);

                out.append("\n");

                out1 = new StringBuffer();

                out2 = new Formatter();

            }

        }

        if (out1.length() > 0) {

            out.append(out1);

            out.append("|");

            out.append(out2);

            out.append("\n");

        }

        return out.toString();

    }

    private double DGNParseIEEE(double d) {

        byte[] temp = new byte[8];

        int[] f = {0};

        ByteUtils.doubleToBytes(d, temp, f);

        return DGNParseIEEE(temp);

    }

    private double DGNParseIEEE(byte[] b) {

        byte BYTE2 = b[7];

        byte BYTE3 = b[6];

        byte BYTE0 = b[5];

        byte BYTE1 = b[4];

        byte BYTE6 = b[3];

        byte BYTE7 = b[2];

        byte BYTE4 = b[1];

        byte BYTE5 = b[0];

        int sign;

        int exponent;

        int fraction;

        double value;

        int hi;

        int lo;

        int rndbits;

        /* -------------------------------------------------------------------- */

        /* Save the sign of the double */

        /* -------------------------------------------------------------------- */

        byte[] temp = new byte[4];

        byte[] temp1 = new byte[4];

        temp[3] = BYTE7;

        temp[2] = BYTE6;

        temp[1] = BYTE5;

        temp[0] = BYTE4;

        int[] f = {0};

        hi = ByteUtils.bytesToInt(temp, f);

        sign = hi & 0x80000000;

        /* -------------------------------------------------------------------- */

        /* Adjust the exponent so that we may work with it */

        /* -------------------------------------------------------------------- */

        exponent = hi >> 23;

        exponent = exponent & 0x000000ff;

        if (exponent != 0) {

            exponent = exponent - 129 + 1023;

        }

        /* -------------------------------------------------------------------- */

        /* Save the bits that we are discarding so we can round properly */

        /* -------------------------------------------------------------------- */

        temp[3] = BYTE3;

        temp[2] = BYTE2;

        temp[1] = BYTE1;

        temp[0] = BYTE0;

        f[0] = 0;

        lo = ByteUtils.bytesToInt(temp, f);

        rndbits = lo & 0x00000007;

        lo = lo >> 3;

        lo = (lo & 0x1fffffff) | (hi << 29);

        if (rndbits != 0) {

            lo = lo | 0x00000001;

        }

        /* -------------------------------------------------------------------- */

        /* Shift the hi-order int over 3 and insert the exponent and sign */

        /* -------------------------------------------------------------------- */

        hi = hi >> 3;

        hi = hi & 0x000fffff;

        hi = hi | (exponent << 20) | sign;

        f[0] = 0;

        ByteUtils.intToBytes(hi, temp, f);

        f[0] = 0;

        ByteUtils.intToBytes(lo, temp1, f);

        byte[] result = new byte[8];

        result[7] = temp1[3];

        result[6] = temp1[2];

        result[5] = temp1[1];