Application: gvSIG desktop » gvSIG data provider for DGN

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

import java.awt.geom.AffineTransform;

import java.awt.geom.Arc2D;

import java.awt.geom.PathIterator;

import java.io.BufferedWriter;

import java.io.File;

import java.io.FileWriter;

import java.io.IOException;

import java.util.ArrayList;

import java.util.Date;

import java.util.HashMap;

import java.util.Iterator;

import java.util.List;

import java.util.Map;

import org.apache.commons.io.IOUtils;

import org.cresques.cts.IProjection;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataManager;

import org.gvsig.fmap.dal.DataServerExplorer;

import org.gvsig.fmap.dal.DataStoreNotification;

import org.gvsig.fmap.dal.DataTypes;

import org.gvsig.fmap.dal.FileHelper;

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

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

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

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

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

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

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

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

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

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

import org.gvsig.fmap.dal.feature.exception.PerformEditingException;

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

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

import org.gvsig.fmap.dal.feature.spi.memory.AbstractMemoryStoreProvider;

import org.gvsig.fmap.dal.resource.ResourceAction;

import org.gvsig.fmap.dal.resource.exception.AccessResourceException;

import org.gvsig.fmap.dal.resource.file.FileResource;

import org.gvsig.fmap.dal.resource.spi.ResourceConsumer;

import org.gvsig.fmap.dal.resource.spi.ResourceProvider;

import org.gvsig.fmap.dal.serverexplorer.filesystem.FilesystemServerExplorer;

import org.gvsig.fmap.dal.serverexplorer.filesystem.FilesystemServerExplorerParameters;

import org.gvsig.fmap.dal.spi.DataStoreProviderServices;

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

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

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

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

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

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

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

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

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

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.Geometry.SUBTYPES;

import org.gvsig.fmap.geom.Geometry.TYPES;

import org.gvsig.fmap.geom.GeometryLocator;

import org.gvsig.fmap.geom.GeometryManager;

import org.gvsig.fmap.geom.exception.CreateEnvelopeException;

import org.gvsig.fmap.geom.exception.CreateGeometryException;

import org.gvsig.fmap.geom.primitive.Envelope;

import org.gvsig.fmap.geom.primitive.GeneralPathX;

import org.gvsig.fmap.geom.primitive.OrientablePrimitive;

import org.gvsig.fmap.geom.primitive.Point;

import org.gvsig.fmap.geom.type.GeometryType;

import org.gvsig.tools.dynobject.exception.DynMethodException;

public class DGNStoreProvider extends AbstractMemoryStoreProvider implements

    ResourceConsumer {

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

    public static final String NAME = "DGN";

    public static final String DESCRIPTION = "DGN file";

    public static final String METADATA_DEFINITION_NAME = NAME;

    public static final String METADATA_DEFINITION_DESCRIPTION = "DGN File Store";

    public static final int LOAD_MODE_PLAIN = 0;

    public static final int LOAD_MODE_GROUP1 = 1;

    public static final int CROP_OPERATION_NONE = 0;

    public static final int CROP_OPERATION_CONTAINS = 1;

    public static final int CROP_OPERATION_COVERS = 2;

    public static final int CROP_OPERATION_COVEREDBY = 3;

    public static final int CROP_OPERATION_CROSSES = 4;

    public static final int CROP_OPERATION_DISJOINT = 5;

    public static final int CROP_OPERATION_INTERSECT = 6;

    public static final int CROP_OPERATION_OVERLAPS = 7;

    public static final int CROP_OPERATION_TOUCHES = 8;

    public static final int CROP_OPERATION_WITHIN = 9;

    public static final int GROUP_GEOMETRIES_NONE = 0;

    public static final int GROUP_GEOMETRIES_CONVEXHULL = 1;

    public static final int GROUP_GEOMETRIES_UNION = 2;

    public static final int GROUP_GEOMETRIES_INTERSECTION = 3;

    public static final int GROUP_GEOMETRIES_TOPOINTS = 4;

    public static final int GROUP_GEOMETRIES_TOLINES = 5;

    public static final int GROUP_GEOMETRIES_TOPOLYGONS = 6;

    public static final int GROUP_GEOMETRIES_TOPOLYGONS_FIX = 7;

    public static final String NAME_FIELD_ID = "ID";

    public static final String NAME_FIELD_GEOMETRY = "Geometry";

    public static final String NAME_FIELD_TYPE = "Type";

    public static final String NAME_FIELD_STYPE = "SType";

    public static final String NAME_FIELD_ENTITY = "Entity";

    public static final String NAME_FIELD_LEVEL = "Layer";

    public static final String NAME_FIELD_COLOR = "Color";

    public static final String NAME_FIELD_FILLCOLOR = "FillColor";

    public static final String NAME_FIELD_ELEVATION = "Elevation";

    public static final String NAME_FIELD_WEIGHT = "Weight";

    public static final String NAME_FIELD_TEXT = "Text";

    public static final String NAME_FIELD_HEIGHTTEXT = "HeightText";

    public static final String NAME_FIELD_HEIGHTTEXTRAW = "HeightTextRaw";

    public static final String NAME_FIELD_ROTATIONTEXT = "Rotation";

    public static final String NAME_FIELD_STYLE = "Style";

    public static final String NAME_FIELD_GROUP = "Group";

    public static final String NAME_FIELD_ISSHAPE = "IsShape";

    public static final String NAME_FIELD_ISCOMPLEXSHAPEHEADER = "IsComplexShapeHeader";

    public static final String NAME_FIELD_ISHOLE = "IsHole";

    public static final String NAME_FIELD_ISCOMPLEX = "IsComplex";

    public static final String NAME_FIELD_PARENTID = "ParentId";

    public static final String NAME_FIELD_SCALE = "Scale";

    public static final String NAME_FIELD_LINKS_COUNT = "LinksCount";

    public static final String NAME_FIELD_LINK_INDEX = "LinkIndex";

    public static final String NAME_FIELD_LINK_TYPE = "LinkType";

    public static final String NAME_FIELD_LINK_ENTITY = "LinkEntity";

    public static final String NAME_FIELD_LINK_MS = "LinkMS";

    public static final String NAME_FIELD_LINK_LENGTH = "LinkLength";

    public static final String NAME_FIELD_LINK_DATA = "LinkData";

    public static final String NAME_FIELD_DATA = "Data";

    private int ID_FIELD_ID;

    private int ID_FIELD_TYPE;

    private int ID_FIELD_STYPE;

    private int ID_FIELD_ENTITY;

    private int ID_FIELD_LEVEL;

    private int ID_FIELD_COLOR;

    private int ID_FIELD_FILLCOLOR;

    private int ID_FIELD_ELEVATION;

    private int ID_FIELD_WEIGHT;

    private int ID_FIELD_TEXT;

    private int ID_FIELD_HEIGHTTEXT;

    private int ID_FIELD_HEIGHTTEXTRAW;

    private int ID_FIELD_ROTATIONTEXT;

    private int ID_FIELD_STYLE;

    private int ID_FIELD_GROUP;

    private int ID_FIELD_LAYER;

    private int ID_FIELD_ISCOMPLEXSHAPEHEADER;

    private int ID_FIELD_ISSHAPE;

    private int ID_FIELD_ISHOLE;

    private int ID_FIELD_ISCOMPLEX;

    private int ID_FIELD_PARENT;

    private int ID_FIELD_SCALE;

    private int ID_FIELD_LINKS_COUNT;

    private int ID_FIELD_LINK_INDEX;

    private int ID_FIELD_LINK_TYPE;

    private int ID_FIELD_LINK_ENTITY;

    private int ID_FIELD_LINK_MS;

    private int ID_FIELD_LINK_LENGTH;

    private int ID_FIELD_LINK_DATA;

    private int ID_FIELD_DATA;

    private int ID_FIELD_GEOMETRY;

    private int MAX_FIELD_ID;

    private IProjection projection;

    private ResourceProvider resource;

    private LegendBuilder legendBuilder;

    private long counterNewsOIDs = 0;

    protected GeometryManager geomManager = GeometryLocator

        .getGeometryManager();

    private int groupByFieldIndex = -2;

    private Map<Object, FeatureProvider> groupedFeatures = null;

    DGNData dgndata = null;

    public DGNStoreProvider(DGNStoreParameters parameters,

        DataStoreProviderServices storeServices) throws InitializeException {

        super(parameters, storeServices, FileHelper

            .newMetadataContainer(METADATA_DEFINITION_NAME));

        counterNewsOIDs = 0;

        // projection = CRSFactory.getCRS(getParameters().getSRSID());

        File file = getDGNParameters().getFile();

        resource =

            this.createResource(FileResource.NAME,

                new Object[] { file.getAbsolutePath() });

        resource.addConsumer(this);

        this.projection = this.getDGNParameters().getCRS();

        try {

            legendBuilder =

                (LegendBuilder) this.invokeDynMethod(

                    LegendBuilder.DYNMETHOD_BUILDER_NAME, null);

        } catch (DynMethodException e) {

            legendBuilder = null;

        } catch (Exception e) {

            throw new InitializeException(e);

        }

        this.initializeFeatureTypes();

    }

    private DGNStoreParameters getDGNParameters() {

        return (DGNStoreParameters) this.getParameters();

    }

    public String getProviderName() {

        return NAME;

    }

    public boolean allowWrite() {

        // not yet

        return false;

    }

    public Object getLegend() throws OpenException {

        this.open();

        if (legendBuilder == null) {

            return null;

        }

        return legendBuilder.getLegend();

    }

    public Object getLabeling() throws OpenException {

        this.open();

        if (legendBuilder == null) {

            return null;

        }

        return legendBuilder.getLabeling();

    }

    private class DGNData {

        public List<FeatureProvider> data = null;

        public FeatureType defaultFType = null;

        public List<FeatureType> fTypes = null;

        public Envelope envelope = null;

        public IProjection projection;

        public LegendBuilder legendBuilder;

        public Envelope getEnvelopeCopy() throws CreateEnvelopeException {

            if (envelope == null) {

                return null;

            }

            try {

                return (Envelope) envelope.clone();

            } catch (CloneNotSupportedException ex) {

                logger.warn("Can't clone envelope.", ex);

                return null;

            }

        }

    }

    public static class TimeCounter {

        private static final Logger logger = LoggerFactory

            .getLogger(TimeCounter.class);

        private long counter = 0;

        private Date t1;

        private Date t2;

        public void start() {

            this.t1 = new Date();

            this.t2 = this.t1;

        }

        public void restart() {

            this.t1 = new Date();

            this.t2 = this.t1;

            this.counter = 0;

        }

        public void stop() {

            this.t2 = new Date();

            this.counter += this.t2.getTime() - this.t1.getTime();

        }

        public long get() {

            return this.counter;

        }

        public void log(String msg) {

            logger.debug("Time " + get() + " ms. " + msg);

        }

        public void restart(String msg) {

            this.stop();

            this.log(msg);

            this.restart();

        }

    }

    public void open() throws OpenException {

        if (this.data != null) {

            return;

        }

        try {

            getResource().execute(new ResourceAction() {

                public Object run() throws Exception {

                    TimeCounter tc = new TimeCounter();

                    tc.start();

                    FeatureStoreProviderServices storeProviderServices = getStoreServices();

                    if (dgndata == null && !(getDGNParameters().useReload())) {

                        if (resource.getData() != null) {

                            dgndata =

                                (DGNData) ((Map) resource.getData())

                                    .get(projection.getAbrev()); // OJO no es del todo correcto (puede llevar reproyeccion)

                        } else {

                            resource.setData(new HashMap());

                        }

                    }

                    tc.restart("Retrive data from resource (data=" + dgndata + ")");

                    if (dgndata == null) {

                        dgndata = new DGNData();

                        dgndata.data = new ArrayList();

                        data = dgndata.data;

                        counterNewsOIDs = 0;

                        Reader reader = new Reader().initialice(getMemoryProvider(), (File) resource.get(), projection, legendBuilder);

                        reader.begin(storeProviderServices);

                        dgndata.defaultFType = reader.getDefaultType().getNotEditableCopy();

                        List types = new ArrayList();

                        Iterator it = reader.getTypes().iterator();

                        EditableFeatureType fType;

                        while (it.hasNext()) {

                            fType = (EditableFeatureType) it.next();

                            if (fType.getId().equals(dgndata.defaultFType.getId())) {

                                types.add(dgndata.defaultFType);

                            } else {

                                types.add(fType.getNotEditableCopy());

                            }

                        }

                        dgndata.fTypes = types;

                        resource.notifyOpen();

                        storeProviderServices.setFeatureTypes(dgndata.fTypes, dgndata.defaultFType);

                        reader.load();

                        dgndata.envelope = reader.getEnvelope();

                        dgndata.legendBuilder = legendBuilder;

                        dgndata.projection = projection;

                        reader.end();

                        if (resource.getData() == null) {

                            resource.setData(new HashMap());

                        }

                        ((Map) resource.getData()).put(projection.getAbrev(),dgndata); // OJO la reproyeccion

                        tc.restart("Loaded data from file (data=" + dgndata + ")");

                        resource.notifyClose();

                    }

                    // El feature type no lo compartimos entre las instancias del

                    // mismo resource ya que puede cambiar en funcion del filtro.

                    // Por lo menos el geometry-type.

                    List<FeatureType> featureTypes = getFeatureTypes(storeProviderServices);

                    tc.restart("Created featuretype (featureTypes=" + featureTypes + ")");

                    PostProcessFeatures postProcess = new PostProcessFeatures(getDGNParameters(), featureTypes.get(0));

                    if (postProcess.hasOperations()) {

                        data = postProcess.apply(dgndata.data);

                        setDynValue("Envelope", postProcess.getEnvelope());

                    } else {

                        data = dgndata.data;

                        setDynValue("Envelope", dgndata.getEnvelopeCopy());

                    }

                    tc.restart("PostProcessFeatures");

                    legendBuilder = dgndata.legendBuilder;

                    storeProviderServices.setFeatureTypes(featureTypes, featureTypes.get(0));

                    setDynValue("CRS", projection);

                    counterNewsOIDs = data.size();

                    tc.restart("load finished.");

                    return null;

                }

            });

        } catch (Exception e) {

            data = null;

            try {

                throw new OpenException(resource.getName(), e);

            } catch (AccessResourceException e1) {

                throw new OpenException(getProviderName(), e);

            }

        }

    }

    public DataServerExplorer getExplorer() throws ReadException {

        DataManager manager = DALLocator.getDataManager();

        FilesystemServerExplorerParameters params;

        try {

            params = (FilesystemServerExplorerParameters) manager.createServerExplorerParameters(FilesystemServerExplorer.NAME);

            params.setRoot(this.getDGNParameters().getFile().getParent());

            return manager.openServerExplorer(FilesystemServerExplorer.NAME, params);

        } catch (DataException e) {

            throw new ReadException(this.getProviderName(), e);

        } catch (ValidateDataParametersException e) {

            throw new ReadException(this.getProviderName(), e);

        }

    }

    public void performChanges(Iterator deleteds, Iterator inserteds,

        Iterator updateds, Iterator originalFeatureTypesUpdated)

        throws PerformEditingException {

        // FIXME Exception

        throw new UnsupportedOperationException();

    }

    public List getFeatureTypes(FeatureStoreProviderServices store) {

        //FIXME: Habr?a que distinguir cuando se va a crear un DGN 3D o 2D, de momento siempre 3D

        return getFeatureTypes(store, Geometry.SUBTYPES.GEOM3D);

    }

    private List getFeatureTypes(FeatureStoreProviderServices store, int subtype) {

        EditableFeatureType featureType = store.createFeatureType(getName());

        featureType.setHasOID(true);

        ID_FIELD_ID = featureType.add(NAME_FIELD_ID, DataTypes.INT)

                .setDefaultValue(Integer.valueOf(0)).getIndex();

        ID_FIELD_PARENT = featureType.add(NAME_FIELD_PARENTID, DataTypes.INT)

                .setDefaultValue(Integer.valueOf(0)).getIndex();

        // FIXME: Cual es el size y el valor por defecto para Entity ?

        ID_FIELD_ENTITY = featureType.add(NAME_FIELD_ENTITY, DataTypes.STRING, 100)

                .setDefaultValue("").getIndex();

        // FIXME: Cual es el size de Layer ?

        ID_FIELD_LEVEL = featureType.add(NAME_FIELD_LEVEL, DataTypes.STRING, 100)

                .setDefaultValue("default").getIndex();

        ID_FIELD_LAYER = ID_FIELD_LEVEL;

        ID_FIELD_COLOR = featureType.add(NAME_FIELD_COLOR, DataTypes.INT)

                .setDefaultValue(Integer.valueOf(0)).getIndex();

        // FIXME: Cual es el size de Text ?

        ID_FIELD_TEXT = featureType.add(NAME_FIELD_TEXT, DataTypes.STRING, 100)

                .setDefaultValue("").getIndex();

        ID_FIELD_HEIGHTTEXT = featureType.add(NAME_FIELD_HEIGHTTEXT, DataTypes.DOUBLE)

                .setDefaultValue(Double.valueOf(10)).getIndex();

        ID_FIELD_HEIGHTTEXTRAW = featureType.add(NAME_FIELD_HEIGHTTEXTRAW, DataTypes.DOUBLE)

                .setDefaultValue(Double.valueOf(10)).getIndex();

        ID_FIELD_ROTATIONTEXT = featureType.add(NAME_FIELD_ROTATIONTEXT, DataTypes.DOUBLE)

                .setDefaultValue(Double.valueOf(0)).getIndex();

        ID_FIELD_TYPE = featureType.add(NAME_FIELD_TYPE, DataTypes.INT)

                .setDefaultValue(Integer.valueOf(0)).getIndex();

        ID_FIELD_STYPE = featureType.add(NAME_FIELD_STYPE, DataTypes.INT)

                .setDefaultValue(Integer.valueOf(0)).getIndex();

        ID_FIELD_FILLCOLOR = featureType.add(NAME_FIELD_FILLCOLOR, DataTypes.INT)

                .setDefaultValue(Integer.valueOf(0)).getIndex();

        ID_FIELD_STYLE = featureType.add(NAME_FIELD_STYLE, DataTypes.INT)

                .setDefaultValue(Integer.valueOf(0)).getIndex();

        ID_FIELD_ELEVATION = featureType.add(NAME_FIELD_ELEVATION, DataTypes.DOUBLE)

                .setDefaultValue(Double.valueOf(0)).getIndex();

        ID_FIELD_WEIGHT = featureType.add(NAME_FIELD_WEIGHT, DataTypes.DOUBLE)

                .setDefaultValue(Double.valueOf(0)).getIndex();

        ID_FIELD_GROUP = featureType.add(NAME_FIELD_GROUP, DataTypes.INT)

                .setDefaultValue(Integer.valueOf(0)).getIndex();

        ID_FIELD_ISSHAPE = featureType.add(NAME_FIELD_ISSHAPE, DataTypes.BOOLEAN)

                .setDefaultValue(Boolean.FALSE).getIndex();

        ID_FIELD_ISCOMPLEXSHAPEHEADER = featureType.add(NAME_FIELD_ISCOMPLEXSHAPEHEADER, DataTypes.BOOLEAN)

                .setDefaultValue(Boolean.FALSE).getIndex();

        ID_FIELD_ISHOLE = featureType.add(NAME_FIELD_ISHOLE, DataTypes.BOOLEAN)

                .setDefaultValue(Boolean.FALSE).getIndex();

        ID_FIELD_ISCOMPLEX = featureType.add(NAME_FIELD_ISCOMPLEX, DataTypes.BOOLEAN)

                .setDefaultValue(Boolean.FALSE).getIndex();

        ID_FIELD_SCALE = featureType.add(NAME_FIELD_SCALE, DataTypes.INT)

                .setDefaultValue(Integer.valueOf(0)).getIndex();

        ID_FIELD_LINKS_COUNT = featureType.add(NAME_FIELD_LINKS_COUNT, DataTypes.INT)

                .setDefaultValue(Integer.valueOf(0)).getIndex();

        ID_FIELD_LINK_INDEX = featureType.add(NAME_FIELD_LINK_INDEX, DataTypes.INT)

                .setDefaultValue(Integer.valueOf(0)).getIndex();

        ID_FIELD_LINK_ENTITY = featureType.add(NAME_FIELD_LINK_ENTITY, DataTypes.INT)

                .setDefaultValue(Integer.valueOf(0)).getIndex();

        ID_FIELD_LINK_TYPE = featureType.add(NAME_FIELD_LINK_TYPE, DataTypes.INT)

                .setDefaultValue(Integer.valueOf(0)).getIndex();

        ID_FIELD_LINK_MS = featureType.add(NAME_FIELD_LINK_MS, DataTypes.INT)

                .setDefaultValue(Integer.valueOf(0)).getIndex();

        ID_FIELD_LINK_LENGTH = featureType.add(NAME_FIELD_LINK_LENGTH, DataTypes.INT)

                .setDefaultValue(Integer.valueOf(0)).getIndex();

        ID_FIELD_LINK_DATA = featureType.add(NAME_FIELD_LINK_DATA, DataTypes.STRING, 512)

                .setDefaultValue("").getIndex();

        ID_FIELD_DATA = featureType.add(NAME_FIELD_DATA, DataTypes.STRING, 512)

                .setDefaultValue("").getIndex();

        EditableFeatureAttributeDescriptor attr = featureType.add(NAME_FIELD_GEOMETRY, DataTypes.GEOMETRY);

        attr.setSRS(this.projection);

        int geometryTypeToUse = getDGNParameters().getGeometryTypeFilter();

        if (getDGNParameters().getGroupBy() != null) {

            switch (getDGNParameters().getGroupGeometriesOperation()) {

            case GROUP_GEOMETRIES_NONE:

            case GROUP_GEOMETRIES_UNION:

            case GROUP_GEOMETRIES_INTERSECTION:

                break;

            case GROUP_GEOMETRIES_TOPOINTS:

                geometryTypeToUse = Geometry.TYPES.MULTIPOINT;

                break;

            case GROUP_GEOMETRIES_TOLINES:

                geometryTypeToUse = Geometry.TYPES.MULTICURVE;

                break;

            case GROUP_GEOMETRIES_TOPOLYGONS:

            case GROUP_GEOMETRIES_TOPOLYGONS_FIX:

            case GROUP_GEOMETRIES_CONVEXHULL:

                geometryTypeToUse = Geometry.TYPES.MULTISURFACE;

                break;

            }

        }

        try {

            attr.setGeometryType(GeometryLocator.getGeometryManager()

                .getGeometryType(geometryTypeToUse, subtype));

        } catch (Exception e) {

            attr.setGeometryType(geometryTypeToUse);

            attr.setGeometrySubType(subtype);

        }

        ID_FIELD_GEOMETRY = attr.getIndex();

        featureType.setDefaultGeometryAttributeName(NAME_FIELD_GEOMETRY);

        MAX_FIELD_ID = featureType.size() - 1;

        List types = new ArrayList();

        types.add(featureType);

        return types;

    }

    public class Reader {

        private File file;

        private IProjection projection;

        private List types;

        private LegendBuilder leyendBuilder;

        private AbstractMemoryStoreProvider storeProvider;

        private Envelope envelope;

        public Reader initialice(AbstractMemoryStoreProvider storeProvider, File file,

            IProjection projection, LegendBuilder leyendBuilder) {

            this.storeProvider = storeProvider;

            this.file = file;

            this.projection = projection;

            this.leyendBuilder = leyendBuilder;

            if (leyendBuilder != null) {

                leyendBuilder.initialize(storeProvider);

            }

            return this;

        }

        public Envelope getEnvelope() {

            return this.envelope;

        }

        public void begin(FeatureStoreProviderServices storeProviderServices) {

            types = getFeatureTypes(storeProviderServices);

            if (leyendBuilder != null) {

                leyendBuilder.begin();

            }

        }

        public void end() {

            if (leyendBuilder != null) {

                leyendBuilder.end();

            }

        }

        public List getTypes() {

            return types;

        }

        public EditableFeatureType getDefaultType() {

            return (EditableFeatureType) types.get(0);

        }

        public void load() throws DataException, CreateEnvelopeException {

            switch (getDGNParameters().getLoadMode()) {

            case LOAD_MODE_PLAIN:

            default:

                load_plain();

                break;

            case LOAD_MODE_GROUP1:

                load_group1();

                break;

            }

        }

        public void load_plain() throws DataException {

            FileWriter xmlfw = null;

            BufferedWriter xmlbfw = null;

            this.envelope = null;

            boolean ignoreZs = getDGNParameters().ignoreZs();

            boolean useZAsElevation = getDGNParameters().useZAsElevation();

            boolean applyRoundToElevation = getDGNParameters().getApplyRoundToElevation();

            double elevationFactor = getDGNParameters().geElevationFactor();

            try {

                if (getDGNParameters().getXMLFile() != null) {

                    File xmlfile = getDGNParameters().getXMLFile();

                    try {

                        xmlfw = new FileWriter(xmlfile);

                        xmlbfw = new BufferedWriter(xmlfw);

                    } catch (Exception ex) {

                        xmlfw = null;

                        xmlbfw = null;

                        logger.warn("Can't open xmfile for output (" + xmlfile.getAbsolutePath() + "'.", ex);

                    }

                    if (xmlbfw != null) {

                        try {

                            xmlbfw.write("<DGN>\n");

                        } catch (IOException ex) {

                            logger.warn("Can't write to the xml file.", ex);

                        }

                    }

                }

                DGNReader dgnReader = new DGNReader(file.getAbsolutePath(), getDGNParameters().logErrors());

                // FIXME: De momento forzamos a que todas las geometr?as que se

                // creen sean 3D porque el m?todo getFeatureTypes solo puede

                // crear los geometryAttributes como 3D

                int subtypeHeader;

                    subtypeHeader = Geometry.SUBTYPES.GEOM3D;

                envelope = geomManager.createEnvelope(subtypeHeader);

                FeatureType type = getDefaultType().getNotEditableCopy();

                int counterOfElement = 0;

                DGNElemComplexHeader parentElement = null;

                double zvalue = 0;

                for (int id = 0; id < dgnReader.getNumEntities(); id++) {

                    dgnReader.DGNGotoElement(id);

                    DGNElemCore elemento = dgnReader.DGNReadElement();

                    if (elemento == null) {

                        continue;

                    }

                    if (parentElement != null) {

                        counterOfElement++;

                        if (parentElement.getNumElements() < counterOfElement) {

                            // Ya hemos terminado de recorrer el elemento complejo.

                            parentElement = null;

                        }

                    }

                    if (xmlbfw != null) {

                        // Volcamos el elemnto del DGN a fichero en formato XML

                        try {

                            xmlbfw.write(dgnReader.DGNDumpElement(dgnReader.getInfo(), elemento));

                        } catch (IOException ex) {

                            logger.warn("Can't write to the xml file.", ex);

                        }

                    }

                    if (elemento.isDeleted()) {

                        // Saltamos los elementos borrados.

                        continue;

                    }

                    FeatureProvider data = createFeatureProvider(type);

                    data.set(ID_FIELD_ID, elemento.getID());

                    data.set(ID_FIELD_TYPE, elemento.getType());

                    data.set(ID_FIELD_STYPE, elemento.getSType());

                    data.set(ID_FIELD_LEVEL, elemento.getLevelAsString());

                    data.set(ID_FIELD_COLOR, elemento.getColor());

                    data.set(ID_FIELD_FILLCOLOR, elemento.getShapeFillColor());

                    data.set(ID_FIELD_ENTITY, elemento.getEntityName());

                    data.set(ID_FIELD_STYLE, elemento.getStyle());

                    data.set(ID_FIELD_WEIGHT, elemento.getWeight());

                    data.set(ID_FIELD_GROUP, elemento.getGroup());

                    data.set(ID_FIELD_ELEVATION, elemento.getElevation());

                    data.set(ID_FIELD_ISCOMPLEXSHAPEHEADER,elemento.isComplexShapeHeader());

                    data.set(ID_FIELD_ISSHAPE, elemento.isShape());

                    data.set(ID_FIELD_ISHOLE, elemento.isHole());

                    data.set(ID_FIELD_ISCOMPLEX, elemento.isComplex());

                    data.set(ID_FIELD_HEIGHTTEXT, 0);

                    data.set(ID_FIELD_HEIGHTTEXTRAW, 0);

                    data.set(ID_FIELD_ROTATIONTEXT, 0);

                    data.set(ID_FIELD_TEXT, null);

                    data.set(ID_FIELD_SCALE, dgnReader.getInfo().scale);

                    data.set(ID_FIELD_DATA, elemento.getDataAsHexadecimal());

                    if (parentElement == null) {

                        data.set(ID_FIELD_PARENT, elemento.getID());

                    } else {

                        data.set(ID_FIELD_PARENT, parentElement.getID());

                    }

                    data.set(ID_FIELD_LINKS_COUNT,dgnReader.DGNGetLinkageCount(elemento));

                    DGNLink dgnlink = dgnReader.DGNGetLinkage(elemento,

                            getDGNParameters().getLinkFilterIndex(),

                            getDGNParameters().getLinkFilterType(),

                            getDGNParameters().getLinkFilterEntity(),

                            getDGNParameters().getLinkFilterMS(),

                            getDGNParameters().getLinkFilterDataAsPattern()

                    );

                    if (dgnlink != null) {

                        data.set(ID_FIELD_LINK_INDEX, dgnlink.getIndex());

                        data.set(ID_FIELD_LINK_TYPE, dgnlink.getType());

                        data.set(ID_FIELD_LINK_ENTITY, dgnlink.getEntityCode());

                        data.set(ID_FIELD_LINK_MS, dgnlink.getMSLink());

                        data.set(ID_FIELD_LINK_LENGTH, dgnlink.getLength());

                        data.set(ID_FIELD_LINK_DATA,dgnlink.getDataAsHexadecimal());

                    } else {

                        data.set(ID_FIELD_LINK_INDEX, -1);

                        data.set(ID_FIELD_LINK_TYPE, 0);

                        data.set(ID_FIELD_LINK_ENTITY, 0);

                        data.set(ID_FIELD_LINK_MS, 0);

                        data.set(ID_FIELD_LINK_LENGTH, 0);

                        data.set(ID_FIELD_LINK_DATA, "");

                    }

                    zvalue = 0;

                    try {

                        int subtypeElement;

                        switch (elemento.stype) {

                        case DGNFileHeader.DGNST_COMPLEX_HEADER:

                            parentElement = (DGNElemComplexHeader) elemento;

                            counterOfElement = 0;

                            break;

                        case DGNFileHeader.DGNST_MULTIPOINT:

                            DGNElemMultiPoint dgnmultipoint = (DGNElemMultiPoint) elemento;

                            if (dgnmultipoint.isPoint()) {

                                DGNPoint p = dgnmultipoint.getPoint(0);

                                Point point = createPoint(p.getX(), p.getY(), ignoreZs ? 0 : p.getZ());

                                data.setDefaultGeometry(point);

                                zvalue = p.getZ();

                            } else {

                                OrientablePrimitive geom = null;

                                subtypeElement = getGeometrySubType(dgnmultipoint);

                                if (dgnmultipoint.isPolygon()) {

                                    geom = (OrientablePrimitive) geomManager.create(Geometry.TYPES.SURFACE,subtypeHeader);

                                } else {

                                    geom = (OrientablePrimitive) geomManager.create(Geometry.TYPES.CURVE,subtypeHeader);

                                }

                                // Si es una curva nos saltamos los dos primeros y los dos ultimos vertices.

                                int first = 0;

                                int numVertices = dgnmultipoint.getNumVertices();

                                if (dgnmultipoint.isCurve()) {

                                    first = 2;

                                    numVertices = dgnmultipoint.getNumVertices() - 2;

                                }

                                if (dgnmultipoint.isHole()) {

                                    // Invertimos el orden porque es un agujero

                                    for (int i = numVertices - 2; i >= first; i--) {

                                        DGNPoint p = dgnmultipoint.getVertex(i);

                                        zvalue = p.getZ();

                                        addVertex(geom, p.getX(), p.getY(), ignoreZs ? 0 : zvalue);

                                    }

                                } else {

                                    for (int i = first; i < numVertices; i++) {

                                        DGNPoint p = dgnmultipoint.getVertex(i);

                                        zvalue = p.getZ();

                                        addVertex(geom, p.getX(), p.getY(), ignoreZs ? 0 : zvalue);

                                    }

                                }

                                data.setDefaultGeometry(geom);

                            }

                            break;

                        case DGNFileHeader.DGNST_ARC:

                            DGNElemArc dgnarc = (DGNElemArc) elemento;

                            // La definici?n de arco de MicroStation es distinta a la de Java.

                            // En el dgn el origen se entiende que es el centro del arco,

                            // y a la hora de crear un Arc2D las 2 primeras coordenadas son

                            // la esquina inferior izquierda del rect?ngulo que rodea al arco.

                            // 1.- Creamos la elipse sin rotaci?n.

                            // 2.- Creamos el arco

                            // 3.- Rotamos el resultado

                            AffineTransform mT =

                                AffineTransform.getRotateInstance(

                                    Math.toRadians(dgnarc.rotation),

                                    dgnarc.origin.x, dgnarc.origin.y);

                            Arc2D.Double elArco = new Arc2D.Double(

                                    dgnarc.origin.x - dgnarc.primary_axis,

                                    dgnarc.origin.y - dgnarc.secondary_axis,

                                    2.0 * dgnarc.primary_axis,

                                2.0 * dgnarc.secondary_axis,

                                -dgnarc.startang, -dgnarc.sweepang,

                                Arc2D.OPEN);

                            zvalue = dgnarc.origin.getZ();

                            PathIterator pathIterator = elArco.getPathIterator(null);

                            GeneralPathX elShapeArc = new GeneralPathX(pathIterator);

                            // Transformamos el GeneralPahtX porque si transformamos

                            // elArco nos lo convierte a GeneralPath y nos guarda las coordenadas en float,

                            // con la correspondiente p?rdida de precisi?n

                            elShapeArc.transform(mT);

                            OrientablePrimitive geom = null;

                            subtypeElement = getGeometrySubType(dgnarc);

                            if (dgnarc.isSurface()) {

                                geom = (OrientablePrimitive) geomManager.create(

                                        Geometry.TYPES.SURFACE, subtypeHeader);

                            } else {

                                geom = (OrientablePrimitive) geomManager.create(

                                        Geometry.TYPES.CURVE, subtypeHeader);

                            }

                            geom.setGeneralPath(elShapeArc);

                            if ((subtypeElement == Geometry.SUBTYPES.GEOM3D || subtypeElement == Geometry.SUBTYPES.GEOM3DM)

                                && !ignoreZs) {

                                for (int i = 0; i < geom.getNumVertices(); i++) {

                                    Point originalvertex = geom.getVertex(i);

                                    Point vertex =

                                        (Point) geomManager.create(Geometry.TYPES.POINT, subtypeElement);

                                    vertex.setCoordinateAt(0,originalvertex.getX());

                                    vertex.setCoordinateAt(1,originalvertex.getY());

                                    vertex.setCoordinateAt(2, zvalue);

                                    geom.setVertex(i, vertex);

                                }

                            } else {

                                //do nothing

                                int a=0;

                            }

                            data.setDefaultGeometry(geom);

                            break;

                        case DGNFileHeader.DGNST_TEXT:

                            DGNElemText dgntext = (DGNElemText) elemento;

                            subtypeElement = getGeometrySubType(dgntext);

                            Point point = (Point) geomManager.create(TYPES.POINT, subtypeHeader);

                            point.setCoordinateAt(0, dgntext.getPoint().getX());

                            point.setCoordinateAt(1, dgntext.getPoint().getY());

                            if (subtypeHeader == Geometry.SUBTYPES.GEOM3D) {

                                if(subtypeElement == Geometry.SUBTYPES.GEOM2D){

                                    point.setCoordinateAt(2, 0);

                                } else {

                                    point.setCoordinateAt(2, dgntext.getPoint().getZ());

                                }

                            }

                            data.set(ID_FIELD_HEIGHTTEXT, dgntext.getHeight());

                            data.set(ID_FIELD_HEIGHTTEXTRAW,dgntext.getRawHeight());

                            data.set(ID_FIELD_ROTATIONTEXT,dgntext.getRotation());

                            data.set(ID_FIELD_TEXT, dgntext.getText());

                            data.setDefaultGeometry(point);

                            break;

                        default:

                            break;

                        } // switch

                    } catch (Exception ex) {

                        logger.warn("Can't process element", ex);

                    }

                    if (useZAsElevation) {

                        if (!DGNStoreProvider.equals(elevationFactor, 1, 0.00001)) {

                            zvalue = zvalue * elevationFactor;

                        }

                        if (applyRoundToElevation) {

                            zvalue = Math.round(zvalue);

                        }

                        data.set(ID_FIELD_ELEVATION, zvalue);

                    }

                    addFeature(data, dgnReader);

                } // for

                EditableFeatureType featureType = storeProvider.getFeatureStore().getDefaultFeatureType().getCopy().getEditable();

                FeatureAttributeDescriptor fad = (FeatureAttributeDescriptor) featureType.get(featureType.getDefaultGeometryAttributeName());

                featureType.remove(fad.getName());

                EditableFeatureAttributeDescriptor efad = featureType.add(fad.getName(), fad.getType(), fad.getSize());

                efad.setDefaultValue(fad.getDefaultValue());

                GeometryType gty = null;

                gty = geomManager.getGeometryType(fad.getGeomType().getType(),subtypeHeader);

                efad.setGeometryType(gty);

                efad.setPrecision(fad.getPrecision());

                featureType.setDefaultGeometryAttributeName(fad.getName());

                if (xmlbfw != null) {

                    try {

                        xmlbfw.write("</DGN>\n");

                    } catch (IOException ex) {

                        logger.warn("Can't write to the xml file.", ex);

                    }

                }

            } catch (Exception ex) {

                logger.warn("Can't process DGN file '" + getFullName() + ".",ex);

                throw new LoadException(ex, getFullName());

            } finally {

                IOUtils.closeQuietly(xmlbfw);

                IOUtils.closeQuietly(xmlfw);

            }

        }

        private int getGeometrySubType(DGNElemCore element) {

            if (getDGNParameters().force2D()) {

                return Geometry.SUBTYPES.GEOM2D;

            }

            return element.is3D() ? Geometry.SUBTYPES.GEOM3D : Geometry.SUBTYPES.GEOM2D;

        }

        private void addVertex(OrientablePrimitive geom, double x, double y,

            double z) {

            if (geom.getDimension() == 2) {

                geom.addVertex(x, y);

            } else {

                geom.addVertex(x, y, z);

            }

        }

        private void fillRow(Object[] row, DGNElemCore elemento, DGNElemComplexHeader parentElement, DGNReader dgnReader) {

            row[ID_FIELD_HEIGHTTEXT] = new Double(0);

            row[ID_FIELD_HEIGHTTEXTRAW] = new Double(0);

            row[ID_FIELD_ROTATIONTEXT] = new Double(0);

            row[ID_FIELD_TEXT] = null;

            row[ID_FIELD_ID] = elemento.getID();

            row[ID_FIELD_TYPE] = elemento.getType();

            row[ID_FIELD_STYPE] = elemento.getSType();

            row[ID_FIELD_LEVEL] = elemento.getLevelAsString();

            row[ID_FIELD_COLOR] = elemento.getColor();

            row[ID_FIELD_FILLCOLOR] = elemento.getShapeFillColor();

            row[ID_FIELD_ENTITY] = elemento.getEntityName();

            row[ID_FIELD_STYLE] = elemento.getStyle();

            row[ID_FIELD_WEIGHT] = elemento.getWeight();

            row[ID_FIELD_GROUP] = elemento.getGroup();

            row[ID_FIELD_ELEVATION] = elemento.getElevation();

            row[ID_FIELD_ISCOMPLEXSHAPEHEADER] = elemento.isComplexShapeHeader();

            row[ID_FIELD_ISSHAPE] = elemento.isShape();

            row[ID_FIELD_ISHOLE] = elemento.isHole();

            row[ID_FIELD_ISCOMPLEX] = elemento.isComplex();

            row[ID_FIELD_PARENT] = elemento.getID();

            if (parentElement != null) {

                row[ID_FIELD_PARENT] = parentElement.getID();

            }

            row[ID_FIELD_SCALE] = dgnReader.getInfo().scale;

        }

        public void load_group1() throws DataException, CreateEnvelopeException {

            this.envelope = null;

            FileWriter xmlfw = null;

            BufferedWriter xmlbfw = null;

            if (getDGNParameters().getXMLFile() != null) {

                File xmlfile = getDGNParameters().getXMLFile();

                try {

                    xmlfw = new FileWriter(xmlfile);

                    xmlbfw = new BufferedWriter(xmlfw);

                } catch (Exception ex) {

                    xmlfw = null;

                    xmlbfw = null;

                    logger.warn("Can't open xmfile for output ("+ xmlfile.getAbsolutePath() + "'.", ex);

                }

                if (xmlbfw != null) {

                    try {

                        xmlbfw.write("<DGN>\n");

                    } catch (IOException ex) {

                        logger.warn("Can't write to the xml file.", ex);

                    }

                }

            }

            DGNReader dgnReader = new DGNReader(file.getAbsolutePath());

            if (dgnReader.getInfo().dimension == 2) {

                envelope = geomManager.createEnvelope(Geometry.SUBTYPES.GEOM2D);

            } else {

                envelope = geomManager.createEnvelope(SUBTYPES.GEOM3D);

            }

            FeatureType type = getDefaultType().getNotEditableCopy();

            int fTypeSize = type.size();

            Object[] auxRow = new Object[fTypeSize];

            Object[] cellRow = new Object[fTypeSize];

            Object[] complexRow = new Object[fTypeSize];

            boolean bElementoCompuesto = false;

            boolean bEsPoligono = false;

            boolean bInsideCell = false;

            boolean bFirstHoleEntity = false;

            boolean bConnect = false; // Se usa para que los pol?gonos cierren

            // bien cuando son formas compuestas

            // int contadorSubElementos = 0;

            // int numSubElementos = 0;

            int complex_index_fill_color = -1;

            int nClass; // Para filtrar los elementos de construcci?n, etc.

            GeneralPathX elementoCompuesto = new GeneralPathX(GeneralPathX.WIND_EVEN_ODD);

            int counterOfElement = 0;

            DGNElemComplexHeader parentElement = null;

            for (int id = 0; id < dgnReader.getNumEntities(); id++) {

                dgnReader.DGNGotoElement(id);

                DGNElemCore elemento = dgnReader.DGNReadElement();

                if (parentElement != null) {

                    counterOfElement++;

                    if (parentElement.getNumElements() < counterOfElement) {

                        // Ya hemos terminado de recorrer el elemento complejo.

                        parentElement = null;

                    }

                }

                if (xmlbfw != null && elemento != null) {

                    // Volcamos el elemnto del DGN a fichero en formato XML

                    try {

                        xmlbfw.write(dgnReader.DGNDumpElement(dgnReader.getInfo(), elemento));

                    } catch (IOException ex) {

                        logger.warn("Can't write to the xml file.", ex);

                    }

                }

                nClass = 0;

                fillRow(auxRow, elemento, parentElement, dgnReader);

                auxRow[ID_FIELD_HEIGHTTEXT] = new Double(0);

                auxRow[ID_FIELD_ROTATIONTEXT] = new Double(0);

                auxRow[ID_FIELD_TEXT] = null;

                if (elemento.properties != 0) {

                    nClass = elemento.properties & DGNFileHeader.DGNPF_CLASS;

                }

                if ((elemento != null) && (elemento.deleted == 0)

                    && (nClass == 0)) // Leer un elemento

                {

                    // if ((elemento.element_id > 3800) && (elemento.element_id < 3850))

                    // dgnReader.DGNDumpElement(dgnReader.getInfo(),elemento,"");

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

                        || (elemento.stype == DGNFileHeader.DGNST_ARC)

                        || (elemento.stype == DGNFileHeader.DGNST_CELL_HEADER)

                        || (elemento.stype == DGNFileHeader.DGNST_SHARED_CELL_DEFN)

                        || (elemento.stype == DGNFileHeader.DGNST_COMPLEX_HEADER)) {

                        if (elemento.complex != 0) {

                            bElementoCompuesto = true;

                        } else {

                            if (bElementoCompuesto) {

                                if (bInsideCell) {

                                    auxRow[ID_FIELD_ENTITY] = cellRow[ID_FIELD_ENTITY];

                                } else {

                                    auxRow = complexRow;

                                }

                                addShape(createMultiCurve(elementoCompuesto),

                                    auxRow, type, dgnReader);

                                if (bEsPoligono) {

                                    if (complex_index_fill_color != -1) {

                                        auxRow[ID_FIELD_COLOR] = complex_index_fill_color;

                                    }

                                    addShape(

                                        createMultiSurface(elementoCompuesto),

                                        auxRow, type, dgnReader);

                                }

                                elementoCompuesto = new GeneralPathX(GeneralPathX.WIND_EVEN_ODD);

                            }

                            bElementoCompuesto = false;

                            bEsPoligono = false;

                            bConnect = false;

                            bInsideCell = false;

                        }

                    }

                    switch (elemento.stype) {

                    case DGNFileHeader.DGNST_SHARED_CELL_DEFN:

                        bInsideCell = true;

                        fillRow(cellRow, elemento, parentElement, dgnReader);

                        cellRow[ID_FIELD_ID] = elemento.element_id;

                        cellRow[ID_FIELD_LAYER] = String.valueOf(elemento.level);

                        cellRow[ID_FIELD_COLOR] = elemento.color;

                        cellRow[ID_FIELD_ENTITY] = "Shared Cell";

                        break;

                    case DGNFileHeader.DGNST_CELL_HEADER:

                        bInsideCell = true;

                        fillRow(cellRow, elemento, parentElement, dgnReader);

                        cellRow[ID_FIELD_ID] = elemento.element_id;

                        cellRow[ID_FIELD_LAYER] = String.valueOf(elemento.level);

                        cellRow[ID_FIELD_COLOR] = elemento.color;

                        cellRow[ID_FIELD_ENTITY] = "Cell";

                        complex_index_fill_color = dgnReader.DGNGetShapeFillInfo(elemento);

                        break;

                    case DGNFileHeader.DGNST_COMPLEX_HEADER:

                        // bElementoCompuesto = true;

                        // contadorSubElementos = 0;

                        DGNElemComplexHeader psComplexHeader = (DGNElemComplexHeader) elemento;

                        parentElement = psComplexHeader;

                        counterOfElement = parentElement.getNumElements();

                        // numSubElementos = psComplexHeader.numelems;

                        fillRow(complexRow, elemento, parentElement, dgnReader);

                        complexRow[ID_FIELD_ID] = elemento.element_id;

                        complexRow[ID_FIELD_LAYER] = String.valueOf(elemento.level);

                        complexRow[ID_FIELD_COLOR] = elemento.color;

                        complexRow[ID_FIELD_ENTITY] = "Complex";

                        if (psComplexHeader.type == DGNFileHeader.DGNT_COMPLEX_SHAPE_HEADER) {

                            bEsPoligono = true;

                            // Si es un agujero, no conectamos con el anterior

                            if ((psComplexHeader.properties & 0x8000) != 0) {

                                bFirstHoleEntity = true;

                            } else {

                                // Miramos si tiene color de relleno

                                // complex_index_fill_color = -1;

                                // if (elemento.attr_bytes > 0) {

                                complex_index_fill_color = dgnReader.DGNGetShapeFillInfo(elemento);

                                // }

                            }

                            bConnect = true;

                        } else {

                            bEsPoligono = false;

                            bConnect = false;

                        }

                        break;

                    case DGNFileHeader.DGNST_MULTIPOINT:

                        // OJO: Si lo que viene en este multipoint es un

                        // elemento con type=11 (curve), se trata de una "parametric

                        // spline curve". La vamos a tratar como si no fuera

                        // curva, pero seg?n la documentaci?n, los 2 primeros puntos

                        // y los 2 ?ltimos puntos definen "endpoint derivatives" y NO se muestran.

                        // TODAV?A HAY UN PEQUE?O FALLO CON EL FICHERO

                        // dgn-sample.dgn, pero lo dejo por ahora.

                        // Es posible que tenga que ver con lo de los arcos

                        // (arco distorsionado), que todav?a no est? metido.

                        DGNElemMultiPoint psLine = (DGNElemMultiPoint) elemento;

                        fillRow(auxRow, elemento, parentElement, dgnReader);

                        auxRow[ID_FIELD_ID] = elemento.element_id;

                        auxRow[ID_FIELD_ENTITY] = "Multipoint";

                        auxRow[ID_FIELD_LAYER] = String.valueOf(elemento.level);

                        auxRow[ID_FIELD_COLOR] = elemento.color;

                        if ((psLine.num_vertices == 2)

                            && (psLine.vertices[0].x == psLine.vertices[1].x)

                            && (psLine.vertices[0].y == psLine.vertices[1].y)) {

                            auxRow[ID_FIELD_ENTITY] = "Point";

                            addShape(

                                createPoint(psLine.vertices[0].x,

                                    psLine.vertices[0].y,

                                    psLine.vertices[0].z),

                                auxRow,

                                type, dgnReader);

                        } else {

                            GeneralPathX elShape = new GeneralPathX(GeneralPathX.WIND_EVEN_ODD);

                            if (psLine.type == DGNFileHeader.DGNT_CURVE) {

                                psLine.num_vertices = psLine.num_vertices - 4;

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

                                    psLine.vertices[aux_n] = psLine.vertices[aux_n + 2];

                                }

                            }

                            if ((psLine.type == DGNFileHeader.DGNT_SHAPE)

                                && ((psLine.properties & 0x8000) != 0)) {

                                // Invertimos el orden porque es un agujero

                                elShape.moveTo(

                                    psLine.vertices[psLine.num_vertices - 1].x,

                                    psLine.vertices[psLine.num_vertices - 1].y);

                                for (int i = psLine.num_vertices - 2; i >= 0; i--) {

                                    elShape.lineTo(psLine.vertices[i].x,

                                        psLine.vertices[i].y);

                                }

                            } else {

                                elShape.moveTo(psLine.vertices[0].x,

                                    psLine.vertices[0].y);

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

                                    elShape.lineTo(psLine.vertices[i].x,

                                        psLine.vertices[i].y);

                                }

                            }

                            if ((psLine.vertices[0].x == psLine.vertices[psLine.num_vertices - 1].x)

                                && (psLine.vertices[0].y == psLine.vertices[psLine.num_vertices - 1].y)) {

                                // Lo a?adimos tambi?n como pol?gono

                                bEsPoligono = true;

                                // Miramos si tiene color de relleno

                                if (elemento.attr_bytes > 0) {

                                    elemento.color = dgnReader.DGNGetShapeFillInfo(elemento);

                                    if (elemento.color != -1) {

                                        auxRow[ID_FIELD_COLOR] = elemento.color;

                                    }

                                }

                                if (elemento.complex == 0) {

                                    addShape(createSurface(elShape), auxRow,

                                        type, dgnReader);

                                }

                            }

                            if (elemento.complex != 0) {

                                // Si es un agujero o

                                // es la primera entidad del agujero, lo

                                // a?adimos sin unir al anterior

                                if (bFirstHoleEntity

                                    || ((psLine.type == DGNFileHeader.DGNT_SHAPE) && ((psLine.properties & 0x8000) != 0))) {

                                    elementoCompuesto.append(elShape.getPathIterator(null), false);

                                    bFirstHoleEntity = false;

                                } else {

                                    elementoCompuesto.append(elShape.getPathIterator(null),

                                            bConnect);

                                }

                            } else {

                                addShape(createMultiCurve(elShape), auxRow,

                                    type, dgnReader);

                            }

                        }