Application: gvSIG desktop » gvSIG data provider for DGN

<?xml version= "1.0 "?>

<definitions>

  <version>1.0.0</version>

  <classes>

    <class name="DGN">

      <extends>

      	<class namespace="dal" name="ProviderParameters"/>

      </extends>

      <description>Store the parameters need to open a dgn file</description>

      <fields>

        <!-- General -->

        <field name="file" type="file" mandatory="true">

          <description>dgn file</description>

        </field>

        <field name="CRS" type="crs" mandatory="true">

          <description>The coordinate reference system used in this dgn file</description>

        </field>

        <field name="LoadMode" label="Load mode" defaultValue="0" type="integer" mandatory="false">

          <description>Set the strategy to use for loading DGN elements</description>

     	  <availableValues>

            <value label="Plain">0</value>

            <value label="Group elements (1)">1</value>

     	  </availableValues>

        </field>

        <field name="sortByGeometryType" label="Sort by geometry type" type="Boolean" defaultValue="true" mandatory="false">

          <description>If checked sort the rows of table by the geometry type (none,suface,curve,point)</description>

        </field>

        <field name="force2d" label="Force 2D" type="Boolean" defaultValue="false" mandatory="false">

          <description>If checked and DGN has Z dimension create all geometry in 2D and ignore the Zs.</description>

        </field>

        <field name="Reload" label="Reload" type="Boolean" defaultValue="false" mandatory="false">

          <description>Reload an already loaded DGN as a new layer</description>

        </field>

        <field name="groupby" label="Field for group" type="String" defaultValue="" mandatory="false">

          <description>The field name to use for grouping rows</description>

        </field>

        <field name="GroupGeometriesOperation" label="Group geometries as" type="integer" defaultValue="0" mandatory="false">

          <description>If a 'group by' is applied, apply this operation to the resultant geometries</description>

     	  <availableValues>

            <value label="None, return the agregate">0</value>

            <value label="Convexhull">1</value>

            <value label="Union">2</value>

            <value label="Intersection">3</value>

            <value label="Convert to points">4</value>

            <value label="Convert to line">5</value>

            <value label="Convert to poligon">7</value>

            <value label="Convert to poligon and fix it">7</value>

     	  </availableValues>

        </field>

        <!-- Advanced -->

        <field name="ignoreZ" label="Ignore Z" type="Boolean" defaultValue="false" mandatory="false">

          <description>If checked and DGN has Z dimension, set all Zs to 0.</description>

        </field>

        <field name="useZAsElevation" label="Use Z as elevation" type="Boolean" defaultValue="false" mandatory="false" group="Advanced">

          <description>If set, use the Z value to fill the field elevation.</description>

        </field>

        <field name="elevationFactor" label="Elevation factor" type="Double" defaultValue="1" mandatory="false" group="Advanced">

          <description>Factor to apply to elevation when is retrived from the Z coordinate.</description>

        </field>

        <field name="roundElevation" label="Round elevation" type="Boolean" defaultValue="false" mandatory="false" group="Advanced">

          <description>If set, round the elevation to a integer value. This only apply when get elevation from the coordinete Z.</description>

        </field>

        <field name="LinkFilterIndex" label="Link filter index" type="integer" defaultValue="0" mandatory="false" group="Advanced">

          <description>If set, return the link with this index</description>

        </field>

        <field name="LinkFilterType" label="Link filter type" type="integer" defaultValue="" mandatory="false" group="Advanced">

          <description>If set, return the link with this type</description>

        </field>

        <field name="LinkFilterEntity" label="Link filter entity" type="integer" defaultValue="" mandatory="false" group="Advanced">

          <description>If set, return the link with this entity</description>

        </field>

        <field name="LinkFilterMS" label="Link filter MSLink" type="integer" defaultValue="" mandatory="false" group="Advanced">

          <description>If set, return the link with this MSLink</description>

        </field>

        <field name="LinkFilterData" label="Link filter Data" type="string" defaultValue="" mandatory="false" group="Advanced">

          <description>This is a regular expresion. If set, return the link that match this regular expresion in the data of link represented in hexadecimal value</description>

        </field>

        <!-- Filter -->

        <field name="levelFilter" label="Level" group="Filter" type="String" defaultValue="" mandatory="false">

          <description>If specified load only elements with this level. Can use regular expresion to specify the filter.</description>

        </field>

        <field name="colorFilter" label="Color" group="Filter" type="String" defaultValue="" mandatory="false">

          <description>If specified load only elements with this color. Can use regular expresion to specify the filter.</description>

        </field>

        <field name="styleFilter" label="Style" group="Filter" type="String" defaultValue="" mandatory="false">

          <description>If specified load only elements with this style. Can use regular expresion to specify the filter.</description>

        </field>

        <field name="weightFilter" label="Weight" group="Filter" type="String" defaultValue="" mandatory="false">

          <description>If specified load only elements with this weight. Can use regular expresion to specify the filter.</description>

        </field>

        <field name="typeFilter" label="Type" group="Filter" type="String" defaultValue="" mandatory="false">

          <description>If specified load only elements with this type</description>

        </field>

        <field name="stypeFilter" label="SType" group="Filter" type="String" defaultValue="" mandatory="false">

          <description>If specified load only elements with this stype</description>

        </field>

        <field name="groupFilter" label="Group" group="Filter" type="String" defaultValue="" mandatory="false">

          <description>If specified load only elements with this group</description>

        </field>

        <field name="idFilter" label="Id" group="Filter" type="String" defaultValue="" mandatory="false">

          <description>If specified load only elements with this id</description>

        </field>

        <field name="textFilter" label="Text" group="Filter" type="String" defaultValue="" mandatory="false">

          <description>If specified load only elements that match this text</description>

        </field>

        <field name="geomtypeFilter" label="Geometry type" group="Filter" defaultValue="0" type="Integer" mandatory="false">

          <description>If specified load only elements with this type of geometry</description>

     	  <availableValues>

            <value label="All">0</value>

            <value label="Points">1</value>

            <value label="Lines">2</value>

            <value label="Poligons">3</value>

     	  </availableValues>

        </field>

        <field name="skipCorruptGeometries" label="Skip corrupt geometries" group="Filter" type="Boolean" defaultValue="false" mandatory="false">

          <description>If specified skip corrupt geometries</description>

        </field>

        <field name="cropOperationFilter" label="Crop operation" group="Filter" defaultValue="1" type="Integer" mandatory="false">

          <description>If specified load only elements with this type of geometry</description>

     	  <availableValues>

            <value label="None">0</value>

            <value label="Contains">1</value>

            <value label="Covered by">2</value>

            <value label="Covers">3</value>

            <value label="Crosses">4</value>

            <value label="Disjoint">5</value>

            <value label="Intersect">6</value>

            <value label="Overlaps">7</value>

            <value label="Touches">8</value>

            <value label="With in">9</value>

     	  </availableValues>

        </field>

        <field name="cropFilter" label="Crop to" group="Filter" type="Geometry" defaultValue="" mandatory="false">

          <description>Crop the result to this value</description>

        </field>

        <!-- Debug -->

        <field name="XMLFile" label="Output XML file" type="file" group="Debug" mandatory="false">

          <description>Generate XML file with DGN dump in this file</description>

        </field>

        <!--

        <field name="debugOptions" label="Debug options" type="String" group="Debug" mandatory="false">

          <description></description>

        </field>

        -->

        <field name="logErrors" label="log errors" group="Debug" type="Boolean" defaultValue="false" mandatory="false">

          <description>If checked the log of errors are enabled</description>

        </field>

      </fields>

    </class>

  </classes>

</definitions>  

<?xml version="1.0"?>

<!--

Definitions of metadata fields of a shp file.  

 -->

<definitions>

  <version>1.0.0</version>

  <classes>

    <class name="DGN" namespace="Metadata">

      <extends>

      	<class namespace="Metadata" name="SpatialProvider"/>

      </extends>

      <description>Metadata of a DGN store</description>

      <fields>

      </fields>

    </class>

  </classes>

</definitions>  

org.gvsig.fmap.dal.store.dgn.DGNLibrary

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();

}

/*

 * Created on 07-jul-2004

 *

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

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

 */

/* gvSIG. Sistema de Informaci?n Geogr?fica de la Generalitat Valenciana

 *

 * Copyright (C) 2004 IVER T.I. and Generalitat Valenciana.

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License

 * as published by the Free Software Foundation; either version 2

 * of the License, or (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307,USA.

 *

 */

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

/**

 * Clase utilizada para guardar un elemento de tipo Group.

 *

 * @author FJP

 */

public class DGNElemGroup extends DGNElemCore {

	/*                 typedef struct

	   {

	   Elm_hdr ehdr; // element header

	   Disp_hdr dhdr; // display header

	   short file_chars; // no. of chars. in file spec

	   char file_spec[65] //file specification

	   byte file_num; // file number

	   Fb_opts fb_opts; // file builder options mask

	   Fd_opts fd_opts; // file displayer options mask

	   byte disp_flags[16]; // display flags

	   short lev_flags[8][4]; // level on/off flags

	   long ref_org[3]; // origin in ref file uors

	   double trns_mtrx[9]; // transformation matrix

	   double cnvrs_fact; // conversion factor

	   Group Data Elements (Type 5)

	   long mast_org[3]; // origin in master file uors

	   short log_chars; // characters in logical name

	   char log_name[22]; // logical name (padded)

	   short desc_chars; // characters in description

	   char description[42]; /* description (padded)

	   short lev_sym_mask; // level symbology enable mask

	   short lev_sym[63]; // level symbology descriptor

	   long z_delta; // Z-direction delta

	   short clip_vertices; // clipping vertices

	   Point2d clip_poly[1]; // clipping polygon

	   } Ref_file_type5; */

	public DGNPoint origin = new DGNPoint(); /*!< Origin of ellipse */

	public double primary_axis;

	//=new double[4];	/*!< Primary axis length */

	public double secondary_axis;

	//=new double[4]; /*!< Secondary axis length */

	public double rotation; /*!< Counterclockwise rotation in degrees */

	public double[] quat = new double[4]; //4

	public double startang;

	/*!< Start angle (degrees counterclockwise of primary axis) */

	public double sweepang; /*!< Sweep angle (degrees) */

        public DGNElemGroup(DGNReader dgnreader) {

            super(dgnreader);

        }

}

/**

 * 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 java.util.regex.Pattern;

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) {