Application: gvSIG desktop » gvSIG data provider for DXF

<?xml version= "1.0 "?>

<definitions>

  <version>1.0.0</version>

  <classes>

    <class name="DXFStoreParameters">

       <extends>

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

      </extends>

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

      <fields>

        <field name="File" type="file" mandatory="true" group="Basic">

          <description>dxf file</description>

        </field>

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

          <description>The coordinate reference system used in this dxf file</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="DXF" namespace="Metadata">

      <extends>

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

      </extends>

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

      <fields>

      </fields>

    </class>

  </classes>

</definitions>  

org.gvsig.fmap.dal.store.dxf.DXFLibrary

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

import java.util.List;

import org.gvsig.fmap.dal.DataParameters;

import org.gvsig.fmap.dal.DataStoreProvider;

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

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

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

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

import org.gvsig.tools.dynobject.DynObject;

public class DXFStoreProviderFactory extends AbstractFeatureStoreProviderFactory implements FeatureStoreProviderFactory{

	protected DXFStoreProviderFactory(String name, String description) {

		super(name, description);

	}

	public DataStoreProvider createProvider(DataParameters parameters,

			DataStoreProviderServices providerServices)

			throws InitializeException {

		return new DXFStoreProvider((DXFOpenStoreParameters) parameters, providerServices);

	}

	public DynObject createParameters() {

		return new DXFOpenStoreParameters();

	}

	public int allowCreate() {

		return YES;

	}

	public int allowWrite() {

		return YES;

	}

	public int allowRead() {

		return YES;

	}

	public int hasRasterSupport() {

		return NO;

	}

	public int hasTabularSupport() {

		return YES;

	}

	public int hasVectorialSupport() {

		return YES;

	}

	public int allowMultipleGeometryTypes() {

		return NO;

	}

	public int allowEditableFeatureType() {

		return NO;

	}

}

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

import java.io.File;

import java.io.IOException;

import org.apache.commons.io.FileUtils;

import org.apache.commons.io.FilenameUtils;

import org.cresques.cts.ICRSFactory;

import org.cresques.cts.IProjection;

import org.gvsig.fmap.crs.CRSFactory;

import org.gvsig.fmap.dal.FileHelper;

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

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

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

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

import org.gvsig.tools.dynobject.DelegatedDynObject;

public class DXFOpenStoreParameters

        extends AbstractDataParameters

        implements

        OpenFeatureStoreParameters,

        FilesystemStoreParameters {

    public static final String PARAMETERS_DEFINITION_NAME = "DXFStoreParameters";

    static final String FILE_PARAMTER_NAME = "File";

    static final String CRS_PARAMTER_NAME = "CRS";

    private DelegatedDynObject parameters;

    public DXFOpenStoreParameters() {

        this(PARAMETERS_DEFINITION_NAME);

    }

    protected DXFOpenStoreParameters(String parametersDefinitionName) {

        this(parametersDefinitionName, DXFStoreProvider.NAME);

    }

    public DXFOpenStoreParameters(String parametersDefinitionName, String name) {

        super();

        this.parameters = (DelegatedDynObject) FileHelper.newParameters(parametersDefinitionName);

        this.setDynValue(DataStoreProviderServices.PROVIDER_PARAMTER_NAME, name);

    }

    @Override

    public String getDataStoreName() {

        return (String) this.getDynValue(DataStoreProviderServices.PROVIDER_PARAMTER_NAME);

    }

    @Override

    public String getDescription() {

        return this.getDynClass().getDescription();

    }

    @Override

    protected DelegatedDynObject getDelegatedDynObject() {

        return parameters;

    }

    public void setCRS(String srs) {

        setDynValue(CRS_PARAMTER_NAME, srs);

    }

    public void setCRS(IProjection srs) {

        setDynValue(CRS_PARAMTER_NAME, srs);

    }

    public IProjection getCRS() {

        return (IProjection) getDynValue(CRS_PARAMTER_NAME);

    }

    public String getFileName() {

        if (this.getFile() == null) {

            return null;

        }

        return this.getFile().getPath();

    }

    @Override

    public boolean isValid() {

        if (getCRS() == null) {

            return false;

        }

        return getFileName() != null;

    }

    @Override

    public File getFile() {

        return (File) this.getDynValue(FILE_PARAMTER_NAME);

    }

    @Override

    public void setFile(File file) {

        this.setDynValue(FILE_PARAMTER_NAME, file);

        if (getCRS() == null) {

            String wktEsri = loadPrj(file);

            if (wktEsri != null) {

                IProjection proj = CRSFactory.getCRSFactory().get(ICRSFactory.FORMAT_WKT_ESRI, wktEsri);

                setCRS(proj);

            }

        }

    }

    public void setFile(String file) {

        this.setDynValue(FILE_PARAMTER_NAME, file);

        File dxfFile = (File) this.getDynValue(FILE_PARAMTER_NAME);

        if (getCRS() == null) {

            String wktEsri = loadPrj(dxfFile);

            if (wktEsri != null) {

                IProjection proj = CRSFactory.getCRSFactory().get(ICRSFactory.FORMAT_WKT_ESRI, wktEsri);

                setCRS(proj);

            }

        }

    }

    private String loadPrj(File dxfFile) {

        File prjFile = new File(FilenameUtils.removeExtension(dxfFile.getAbsolutePath()) + ".prj");

        if (prjFile.exists()) {

            try {

                return FileUtils.readFileToString(prjFile);

            } catch (IOException e) {

                return null;

            }

        }

        return null;

    }

}

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

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

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

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

	public void end();

	public Object getLegend();

	public Object getLabeling();

}

/* gvSIG. Geographic Information System of the Valencian Government

 *

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

 * of the Valencian Government (CIT)

 *

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

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

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

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

 *

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

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

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

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

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

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,

 * MA  02110-1301, USA.

 *

 */

/*

 * AUTHORS (In addition to CIT):

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

 */

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

import java.util.ArrayList;

import java.util.List;

import org.gvsig.fmap.dal.DALFileLibrary;

import org.gvsig.fmap.dal.DALFileLocator;

import org.gvsig.fmap.dal.DALLibrary;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.FileHelper;

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

import org.gvsig.metadata.exceptions.MetadataException;

import org.gvsig.tools.library.AbstractLibrary;

import org.gvsig.tools.library.LibraryException;

public class DXFLibrary extends AbstractLibrary {

    @Override

    public void doRegistration() {

        registerAsServiceOf(DALLibrary.class);

        require(DALFileLibrary.class);

    }

	@Override

	protected void doInitialize() throws LibraryException {

	}

	@Override

	protected void doPostInitialize() throws LibraryException {

		List<Throwable> exs = new ArrayList<Throwable>();

		FileHelper.registerParametersDefinition(

				DXFOpenStoreParameters.PARAMETERS_DEFINITION_NAME,

				DXFOpenStoreParameters.class, "DXFParameters.xml");

		try {

			FileHelper.registerMetadataDefinition(

					DXFStoreProvider.METADATA_DEFINITION_NAME,

					DXFStoreProvider.class, "DXFMetadata.xml");

		} catch (MetadataException e) {

			exs.add(e);

		}

		DataManagerProviderServices dataman = (DataManagerProviderServices) DALLocator

				.getDataManager();

		try {

			if (!dataman.getStoreProviders().contains(DXFStoreProvider.NAME)) {

				dataman.registerStoreProviderFactory(new DXFStoreProviderFactory(DXFStoreProvider.NAME, DXFStoreProvider.DESCRIPTION));

			}

		} catch (RuntimeException e) {

			exs.add(e);

		}

		try {

			DALFileLocator.getFilesystemServerExplorerManager()

					.registerProvider(DXFStoreProvider.NAME,

							DXFStoreProvider.DESCRIPTION,

							DXFFilesystemServerProvider.class);

		} catch (RuntimeException e) {

			exs.add(e);

		}

		if (exs.size() > 0) {

			throw new LibraryException(this.getClass(), exs);

		}

	}

}

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

import java.io.File;

import java.io.IOException;

import org.cresques.cts.IProjection;

import org.gvsig.dxf.io.DxfFile;

import org.gvsig.dxf.px.dxf.DxfEntityMaker;

import org.gvsig.fmap.dal.DataServerExplorer;

import org.gvsig.fmap.dal.DataStoreParameters;

import org.gvsig.fmap.dal.NewDataStoreParameters;

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

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

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

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

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

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

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.AbsolutePathRequiredException;

import org.gvsig.fmap.dal.serverexplorer.filesystem.impl.AbstractFilesystemServerExplorerProvider;

import org.gvsig.fmap.dal.serverexplorer.filesystem.spi.FilesystemServerExplorerProvider;

import org.gvsig.fmap.dal.serverexplorer.filesystem.spi.FilesystemServerExplorerProviderServices;

public class DXFFilesystemServerProvider extends AbstractFilesystemServerExplorerProvider

        implements FilesystemServerExplorerProvider, ResourceConsumer {

    private FilesystemServerExplorerProviderServices serverExplorer;

    @Override

    public String getDataStoreProviderName() {

        return DXFStoreProvider.NAME;

    }

    @Override

    public int getMode() {

        return DataServerExplorer.MODE_FEATURE | DataServerExplorer.MODE_GEOMETRY;

    }

    @Override

    public boolean accept(File pathname) {

        return (pathname.getName().toLowerCase().endsWith(".dxf"));

    }

    @Override

    public String getDescription() {

        return DXFStoreProvider.DESCRIPTION;

    }

    @Override

    public boolean canCreate() {

        return true;

    }

    @Override

    public boolean canCreate(NewDataStoreParameters parameters) {

        if (!(parameters instanceof DXFOpenStoreParameters)) {

            throw new IllegalArgumentException(); // FIXME ???

        }

        DXFOpenStoreParameters dxfParams = (DXFOpenStoreParameters) parameters;

        // TODO comporbar si el ftype es correcto (para este formato es fijo)

        File file = new File(dxfParams.getFileName());

        if (dxfParams.getCRS() == null) {

            return false;

        }

        // TODO comprobamos extension del fichero ??

        if (file.exists()) {

            return file.canWrite();

        } else {

            return file.getParentFile().canWrite();

        }

    }

    @Override

    public void create(NewDataStoreParameters parameters, boolean overwrite)

            throws CreateException {

        final IProjection projection = null;

        DXFNewStoreParameters params = (DXFNewStoreParameters) parameters;

        File file = params.getFile();

        if (!file.isAbsolute()) {

            throw new AbsolutePathRequiredException(file.getPath());

        }

        if (file.exists()) {

            if (overwrite) {

                if (!file.delete()) {

                    throw new CreateException(this.getDataStoreProviderName(),

                            new IOException(

                                    "cannot delete file"));

                }

            } else {

                throw new CreateException(this.getDataStoreProviderName(),

                        new IOException(

                                "file already exist"));

            }

        }

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

        final FileResource resource;

        try {

            resource = (FileResource) this.serverExplorer

                    .getServerExplorerProviderServices().createResource(

                            FileResource.NAME,

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

        } catch (InitializeException e1) {

            throw new CreateException(params.getFileName(), e1);

        }

        resource.addConsumer(this);

        try {

            resource.execute(new ResourceAction() {

                public Object run() throws Exception {

                    Builder builder

                            = new Builder().initialice(resource.getFileName(),

                                    projection);

                    resource.notifyOpen();

                    builder.begin();

                    builder.create();

                    builder.end();

                    resource.notifyClose();

                    resource.setData(null); // FIXME: Seguro que hay que ponerlo

                    // a null ??

                    resource.notifyChanges();

                    return null;

                }

            });

        } catch (Exception e) {

            throw new CreateException(params.getFileName(), e);

        } finally {

            resource.removeConsumer(this);

        }

    }

    public class Builder {

        private String fileName;

        private IProjection projection;

        public Builder initialice(String fileName, IProjection projection) {

            this.fileName = fileName;

            this.projection = projection;

            return this;

        }

        public void begin() {

        }

        public void end() {

        }

        public void create() throws IOException {

            DxfEntityMaker entityMaker = new DxfEntityMaker(projection);

            DxfFile dxfFile = new DxfFile(null, fileName, entityMaker);

            dxfFile.setCadFlag(true);

            dxfFile.setDxf3DFlag(false);

            dxfFile.save(fileName);

        }

    }

    @Override

    public NewDataStoreParameters getCreateParameters() throws DataException {

        return new DXFNewStoreParameters();

    }

    @Override

    public void initialize(

            FilesystemServerExplorerProviderServices serverExplorer) {

        this.serverExplorer = serverExplorer;

    }

    @Override

    public void remove(DataStoreParameters parameters) throws RemoveException {

        File file = new File(((DXFOpenStoreParameters) parameters).getFileName());

        if (!file.exists()) {

            throw new RemoveException(this.getDataStoreProviderName(),

                    new FileNotFoundException(file));

        }

        if (!file.delete()) {

            // FIXME throws ???

        }

    }

    public boolean closeResourceRequested(ResourceProvider resource) {

        // while it is using a resource anyone can't close it

        return false;

    }

    @Override

    public void resourceChanged(ResourceProvider resource) {

        //Do nothing

    }

}

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

import java.awt.geom.PathIterator;

import java.awt.geom.Point2D;

import java.io.File;

import java.text.MessageFormat;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.Iterator;

import java.util.List;

import java.util.Map;

import java.util.Vector;

import org.apache.commons.io.FilenameUtils;

import org.cresques.cts.IProjection;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.gvsig.dxf.geo.Point3D;

import org.gvsig.dxf.io.DxfFile;

import org.gvsig.dxf.io.DxfGroup;

import org.gvsig.dxf.io.DxfGroupVector;

import org.gvsig.dxf.px.IObjList;

import org.gvsig.dxf.px.dxf.DxfEntityMaker;

import org.gvsig.dxf.px.dxf.DxfFeatureMaker;

import org.gvsig.dxf.px.dxf.DxfHeaderManager;

import org.gvsig.dxf.px.gml.Feature;

import org.gvsig.dxf.px.gml.LineString;

import org.gvsig.dxf.px.gml.LineString3D;

import org.gvsig.dxf.px.gml.Point;

import org.gvsig.dxf.px.gml.Polygon;

import org.gvsig.dxf.px.gml.Polygon3D;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataManager;

import org.gvsig.fmap.dal.DataServerExplorer;

import org.gvsig.fmap.dal.DataStore;

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.exception.WriteException;

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

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

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

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.exception.ResourceNotifyCloseException;

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

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.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.operation.GeometryOperationContext;

import org.gvsig.fmap.geom.operation.distance.PointDistance;

import org.gvsig.fmap.geom.operation.utils.PointGetAngle;

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

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

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

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

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

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

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

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

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

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dispose.DisposableIterator;

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

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

import org.gvsig.tools.exception.BaseException;

import org.gvsig.tools.exception.NotYetImplemented;

import org.gvsig.tools.locator.LocatorException;

import org.gvsig.tools.logger.FilteredLogger;

import org.gvsig.tools.persistence.PersistentState;

import org.gvsig.tools.persistence.exception.PersistenceException;

import org.gvsig.tools.task.SimpleTaskStatus;

import org.gvsig.tools.task.TaskStatusManager;

/**

 * @author gvSIG team

 *

 */

public class DXFStoreProvider extends AbstractMemoryStoreProvider implements

ResourceConsumer {

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

    public static final String NAME = "DXF";

    public static final String DESCRIPTION = "DXF file";

    public static final String METADATA_DEFINITION_NAME = NAME;

    public static final String NAME_FIELD_ID = "ID";

    public static final String NAME_FIELD_GEOMETRY = "Geometry";

    public static final String NAME_FIELD_ENTITY = "Entity";

    public static final String NAME_FIELD_LAYER = "Layer";

    public static final String NAME_FIELD_COLOR = "Color";

    public static final String NAME_FIELD_ELEVATION = "Elevation";

    public static final String NAME_FIELD_THICKNESS = "Thickness";

    public static final String NAME_FIELD_TEXT = "Text";

    public static final String NAME_FIELD_HEIGHTTEXT = "HeightText";

    public static final String NAME_FIELD_ROTATIONTEXT = "Rotation";

    private static final int ID_FIELD_ID = 0;

    private static final int ID_FIELD_GEOMETRY = 1;

    private static final int ID_FIELD_ENTITY = 2;

    private static final int ID_FIELD_LAYER = 3;

    private static final int ID_FIELD_COLOR = 4;

    private static final int ID_FIELD_ELEVATION = 5;

    private static final int ID_FIELD_THICKNESS = 6;

    private static final int ID_FIELD_TEXT = 7;

    private static final int ID_FIELD_HEIGHTTEXT = 8;

    private static final int ID_FIELD_ROTATIONTEXT = 9;

    private IProjection projection;

    private ResourceProvider resource;

    private LegendBuilder legendBuilder;

    private long counterNewsOIDs = 0;

    private Envelope envelope;

    private Writer writer;

    protected GeometryManager geomManager = GeometryLocator.getGeometryManager();

    private SimpleTaskStatus taskStatus;

    /**

     * @param parameters

     * @param storeServices

     * @throws InitializeException

     */

    public DXFStoreProvider(DXFOpenStoreParameters parameters,

        DataStoreProviderServices storeServices) throws InitializeException {

        super(

            parameters,

            storeServices,

            FileHelper.newMetadataContainer(METADATA_DEFINITION_NAME)

        );

        TaskStatusManager manager = ToolsLocator.getTaskStatusManager();

        this.taskStatus = manager.createDefaultSimpleTaskStatus("DXF");

        counterNewsOIDs = 0;

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

        File file = getDXFParameters().getFile();

        resource = this.createResource(

            FileResource.NAME,

            new Object[] { file.getAbsolutePath() }

        );

        resource.addConsumer(this);

        this.projection = this.getDXFParameters().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 DXFOpenStoreParameters getDXFParameters() {

        return (DXFOpenStoreParameters) this.getParameters();

    }

    public String getProviderName() {

        return NAME;

    }

    public boolean allowWrite() {

        return true;

    }

    /**

     * @return the legend

     * @throws OpenException

     */

    public Object getLegend() throws OpenException {

        this.open();

        if (legendBuilder == null) {

            return null;

        }

        return legendBuilder.getLegend();

    }

    /**

     * @return the labeling strategy

     * @throws OpenException

     */

    public Object getLabeling() throws OpenException {

        this.open();

        if (legendBuilder == null) {

            return null;

        }

        return legendBuilder.getLabeling();

    }

    private class DXFData {

        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;

            }

            Envelope newEnvelope;

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

                newEnvelope = geomManager.createEnvelope(SUBTYPES.GEOM2D);

            } else {

                newEnvelope = geomManager.createEnvelope(SUBTYPES.GEOM3D);

            }

            newEnvelope.setLowerCorner(envelope.getLowerCorner());

            newEnvelope.setUpperCorner(envelope.getUpperCorner());

            return newEnvelope;

        }

    }

    public void open() throws OpenException {

        if (this.data != null) {

            return;

        }

        openEver();

    }

    private void openEver() throws OpenException {

        try {

            this.taskStatus.add();

            getResource().execute(new ResourceAction() {

                public Object run() throws Exception {

                    DXFData dxfData = null;

                    resource.setData(new HashMap<Object, Object>());

                    FeatureStoreProviderServices store = getStoreServices();

                    dxfData = new DXFData();

                    dxfData.data = new ArrayList<FeatureProvider>();

                    data = dxfData.data;

                    counterNewsOIDs = 0;

                    File file = (File) resource.get();

                    Reader reader = new Reader().initialice(

                        getMemoryProvider(),

                        file,

                        projection,

                        legendBuilder

                    );

                    reader.begin(store);

                    dxfData.defaultFType = reader.getDefaultType()

                    .getNotEditableCopy();

                    ArrayList<FeatureType> types = new ArrayList<FeatureType>();

                    Iterator<EditableFeatureType> it = reader.getTypes().iterator();

                    EditableFeatureType fType;

                    while (it.hasNext()) {

                        fType = it.next();

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

                            types.add(dxfData.defaultFType);

                        } else {

                            types.add(fType.getNotEditableCopy());

                        }

                    }

                    dxfData.fTypes = types;

                    resource.notifyOpen();

                    store.setFeatureTypes(dxfData.fTypes, dxfData.defaultFType);

                    reader.load();

                    dxfData.envelope = reader.getEnvelope();

                    dxfData.legendBuilder = legendBuilder;

                    dxfData.projection = projection;

                    reader.end();

                    resource.notifyClose();

                    ((Map<String, DXFData>) resource.getData()).put(projection.getAbrev(),

                        dxfData); // OJO la reproyeccion

                    data = dxfData.data;

                    store.setFeatureTypes(dxfData.fTypes, dxfData.defaultFType);

                    legendBuilder = dxfData.legendBuilder;

                    envelope= dxfData.getEnvelopeCopy();

                    // setDynValue("CRS", projection.getAbrev());

                    counterNewsOIDs = data.size();

                    return null;

                }

            });

            this.taskStatus.terminate();

        } catch (Exception e) {

            data = null;

            this.taskStatus.abort();

            try {

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

            } catch (AccessResourceException e1) {

                throw new OpenException(getProviderName(), e);

            }

        } finally {

            this.taskStatus.remove();

        }

    }

    public DataServerExplorer getExplorer() throws ReadException {

        DataManager manager = DALLocator.getDataManager();

        FilesystemServerExplorerParameters params;

        try {

            params = (FilesystemServerExplorerParameters) manager

            .createServerExplorerParameters(FilesystemServerExplorer.NAME);

            params.setRoot(this.getDXFParameters().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 {

        try {

            this.taskStatus.add();

            taskStatus.message("_preparing");

            getResource().execute(new ResourceAction() {

                public Object run() throws Exception {

                    FeatureSet features = null;

                    DisposableIterator it = null;

                    counterNewsOIDs = 0;

                    try {

                        File file = (File) resource.get();

                        writer = new Writer().initialice(file, projection);

                        features =

                            getStoreServices().getFeatureStore()

                            .getFeatureSet();

                        List<FeatureProvider> newdata = new ArrayList<FeatureProvider>();

                        writer.begin();

                        it = features.fastIterator();

                        taskStatus.setRangeOfValues(0,0);

                        long counter=0;

                        while (it.hasNext()) {

                            taskStatus.setCurValue(counter++);

                            FeatureProvider featureProvider = getStoreServices().getFeatureProviderFromFeature(

                                (org.gvsig.fmap.dal.feature.Feature) it.next());

                            writer.add(featureProvider);

                            featureProvider.setOID(createNewOID());

                            newdata.add(featureProvider);

                        }

                        data = newdata;

                        writer.end();

                        if (writer.getEnvelope() != null){

                            envelope = writer.getEnvelope().getGeometry().getEnvelope();

                        }

                        resource.notifyChanges();

//                        counterNewsOIDs = 0;

                        savePrjFile(file, projection);

                    } finally {

                        if (it != null) {

                            it.dispose();

                        }

                        if (features != null) {

                            features.dispose();

                        }

                    }

                    return null;

                }

            });

            this.taskStatus.terminate();

        } catch (Exception e) {

            this.taskStatus.abort();

            throw new PerformEditingException(getResource().toString(), e);

        } finally {

            this.taskStatus.remove();

        }

    }

    /**

     * @param featureType

     * @param projection

     * @param geometrySubtype

     * @throws LocatorException

     * @throws GeometryTypeNotValidException

     * @throws GeometryTypeNotSupportedException

     */

    public static void initializeFeatureType(EditableFeatureType featureType, IProjection projection, int geometrySubtype) {

        featureType.setHasOID(true);

//        ID_FIELD_ID = 0;

        featureType.add(NAME_FIELD_ID, DataTypes.INT)

        .setDefaultValue(Integer.valueOf(0))

        .getIndex();

        EditableFeatureAttributeDescriptor attr = featureType.add(

            NAME_FIELD_GEOMETRY, DataTypes.GEOMETRY);

        attr.setSRS(projection);

        GeometryManager geometryManager = GeometryLocator.getGeometryManager();

        try {

            GeometryType geometryType = geometryManager.getGeometryType(Geometry.TYPES.GEOMETRY, geometrySubtype);

            attr.setGeometryType(geometryType);

        } catch (GeometryTypeNotSupportedException | GeometryTypeNotValidException e) {

            logger.error("Can't create geometry type " + Geometry.TYPES.GEOMETRY + " with subtype " + geometrySubtype, e);

            attr.setGeometryType(Geometry.TYPES.GEOMETRY);

            attr.setGeometrySubType(geometrySubtype);

        }

//        ID_FIELD_GEOMETRY = 1; //attr.getIndex();

        featureType.setDefaultGeometryAttributeName(NAME_FIELD_GEOMETRY);

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

//        ID_FIELD_ENTITY = 2;

        featureType.add(NAME_FIELD_ENTITY,

            DataTypes.STRING, 100)

            .setDefaultValue("")

            .getIndex();

        // FIXME: Cual es el size de Layer ?

//        ID_FIELD_LAYER = 3;

        featureType.add(NAME_FIELD_LAYER,

            DataTypes.STRING, 100)

            .setDefaultValue(

            "default").getIndex();

//        ID_FIELD_COLOR = 4;

        featureType.add(NAME_FIELD_COLOR,

            DataTypes.INT)

            .setDefaultValue(

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

//        ID_FIELD_ELEVATION = 5;

        featureType.add(NAME_FIELD_ELEVATION,

            DataTypes.DOUBLE)

            .setDefaultValue(

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

//        ID_FIELD_THICKNESS = 6;

        featureType.add(NAME_FIELD_THICKNESS,

            DataTypes.DOUBLE)

            .setDefaultValue(

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

        // FIXME: Cual es el size de Text ?

//        ID_FIELD_TEXT = 7;

        featureType.add(NAME_FIELD_TEXT,

            DataTypes.STRING, 100)

            .setDefaultValue("")

            .getIndex();

//        ID_FIELD_HEIGHTTEXT = 8;

        featureType.add(NAME_FIELD_HEIGHTTEXT,

            DataTypes.DOUBLE).setDefaultValue(

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

//        ID_FIELD_ROTATIONTEXT = 9;

        featureType.add(NAME_FIELD_ROTATIONTEXT,

            DataTypes.DOUBLE).setDefaultValue(

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

        // FIXME: Parece que el DXF puede tener mas atributos opcionales.

        // Habria que ver de pillarlos ?

    }

    /**

     * @author gvSIG team

     *

     */

    public class Reader {

        private File file;

        private String fileName;

        private IProjection projection;

        private List<EditableFeatureType> types;

        private LegendBuilder leyendBuilder;

        private AbstractMemoryStoreProvider store;

        private Envelope envelope;

        //Next two variables are used to read the DXF file

        private DxfFeatureMaker featureMaker;

        private DxfHeaderManager headerManager;

        /**

         * @param store

         * @param file

         * @param projection

         * @param leyendBuilder

         * @return the reader

         */

        public Reader initialice(AbstractMemoryStoreProvider store, File file,

            IProjection projection,

            LegendBuilder leyendBuilder) {

            this.store = store;

            this.file = file;

            this.fileName = file.getAbsolutePath();

            this.projection = projection;

            this.leyendBuilder = leyendBuilder;

            if (leyendBuilder != null) {

                leyendBuilder.initialize(store);

            }

            return this;

        }

        /**

         * @return the envelope

         */

        public Envelope getEnvelope() {

            return this.envelope;

        }

        /**

         * @param store

         * @throws LoadException

         */

        public void begin(FeatureStoreProviderServices store) throws LoadException {

            taskStatus.message("_preloading_data");

            featureMaker = new DxfFeatureMaker(projection);

            headerManager = new DxfHeaderManager();

            DxfFile dxfFeatureFile = new DxfFile(projection, file

                .getAbsolutePath(), featureMaker, headerManager);

            try {

                dxfFeatureFile.load();

            } catch (Exception e1) {

                throw new LoadException(e1, fileName);

            }

            taskStatus.message("_preparing_featureType");

            int geometrySubtype;

			if (featureMaker.isDxf3DFile() && headerManager.isWritedDxf3D()){

                geometrySubtype = Geometry.SUBTYPES.GEOM3D;

            }else{

            	geometrySubtype = Geometry.SUBTYPES.GEOM2D;

            }

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

			initializeFeatureType(featureType, this.projection, geometrySubtype);

            types = new ArrayList<EditableFeatureType>();

            types.add(featureType);

            if (leyendBuilder != null) {

                taskStatus.message("_preparing_leyend");

                leyendBuilder.begin();

            }

        }

        /**

         *

         */

        public void end() {

            if (leyendBuilder != null) {

                leyendBuilder.end();

            }

        }

        /**

         * @return the list of feature types

         */

        public List<EditableFeatureType> getTypes() {

            return types;

        }

        /**

         * @return the default editable feature type

         */

        public EditableFeatureType getDefaultType() {

            return types.get(0);

        }

        private Double toDouble(String value) {

            if (value == null) {

                return Double.valueOf(0);

            }

            return Double.valueOf(value);

        }

        private FeatureProvider createFeature(Feature fea, FeatureType ft, int id) throws DataException {

            FeatureProvider feature = store.createFeatureProvider(ft);

            feature.setOID(new Long(id));

            feature.set(ID_FIELD_ID, Integer.valueOf(id));

            feature.set(ID_FIELD_ENTITY, fea.getProp("dxfEntity"));

            feature.set(ID_FIELD_LAYER, fea.getProp("layer"));

            feature.set(ID_FIELD_COLOR, Integer.valueOf(fea.getProp("color")));

            feature.set(ID_FIELD_TEXT, fea.getProp("text"));

            feature.set(ID_FIELD_HEIGHTTEXT, toDouble(fea.getProp("textHeight")));

            feature.set(ID_FIELD_ROTATIONTEXT, toDouble(fea.getProp("textRotation")));

            feature.set(ID_FIELD_ELEVATION, toDouble(fea.getProp("elevation")));

            feature.set(ID_FIELD_THICKNESS, toDouble(fea.getProp("thickness")));

            feature.set(ID_FIELD_GEOMETRY, null);

            // FIXME: Habria que pillar el resto de atributos del DXF.

            // FIXME: Habia una incongruencia en el codigo ya que al

            // campo

            // ID_FIELD_GEOMETRY igual le asignaba una geometria que un

            // valor de cadena como 'Point3D', 'Polyline2D' o

            // 'Polyline3D'

            // Faltaria un atributo ID_FIELD_FSHAPE ?

            //

            return feature;

        }

        private Geometry processPoints(GeometryManager gManager, Feature dxffeature) throws CreateGeometryException {

            if (dxffeature.getGeometry() instanceof org.gvsig.dxf.px.gml.Point3D) {

                org.gvsig.dxf.px.gml.Point3D point = (org.gvsig.dxf.px.gml.Point3D) dxffeature.getGeometry();

                Point3D pto = point.getPoint3D(0);

                org.gvsig.fmap.geom.primitive.Point geom = gManager.createPoint(pto.getX(), pto.getY(), SUBTYPES.GEOM3D);

                geom.setCoordinateAt(Geometry.DIMENSIONS.Z, pto.getZ());

                if (point.isTextPoint()) {

                    /// TODO labeling

                }

                return geom;

            }

            if (dxffeature.getGeometry() instanceof Point) {

                Point point = (Point) dxffeature.getGeometry();

                Point2D pto = point.get(0);

                org.gvsig.fmap.geom.primitive.Point geom = gManager.createPoint(pto.getX(), pto.getY(), SUBTYPES.GEOM2D);

                if (point.isTextPoint()) {

                    /// TODO labeling

                }

                return geom;

            }

            return null;

        }

        private Geometry processLines(GeometryManager gManager, Feature dxffeature) throws CreateGeometryException {

            if (dxffeature.getGeometry() instanceof LineString3D) {

                Line line = gManager.createLine(SUBTYPES.GEOM3D);

                for (int j = 0; j < dxffeature.getGeometry().pointNr(); j++) {

                    Point3D point = ((LineString3D) dxffeature.getGeometry()).getPoint3D(j);

                    line.addVertex(point.getX(), point.getY(), point.getZ());

                }

                return line;

            }

            if (dxffeature.getGeometry() instanceof LineString) {

                Line line = gManager.createLine(SUBTYPES.GEOM2D);

                for (int j = 0; j < dxffeature.getGeometry().pointNr(); j++) {

                    Point2D point = dxffeature.getGeometry().get(j);

                    line.addVertex(point.getX(), point.getY());

                }

                return line;

            }

            return null;

        }

        private Geometry processPolygons(GeometryManager gManager, Feature dxffeature) throws CreateGeometryException {

            org.gvsig.dxf.px.gml.Geometry geom = dxffeature.getGeometry();

            if( geom instanceof Polygon ) {

                if ( ((Polygon) geom).is3D() ) {

                    org.gvsig.fmap.geom.primitive.Polygon polygon = gManager.createPolygon(SUBTYPES.GEOM3D);

                    for (int j = 0; j < dxffeature.getGeometry().pointNr(); j++) {

                        Point3D point = (Point3D) dxffeature.getGeometry().get(j);

                        polygon.addVertex(point.getX(), point.getY(), point.getZ());

                    }

                    Point3D point = (Point3D) dxffeature.getGeometry().get(0);

                    polygon.addVertex(point.getX(), point.getY(), point.getZ());

                    return polygon;

                } else {

                    org.gvsig.fmap.geom.primitive.Polygon polygon = gManager.createPolygon(SUBTYPES.GEOM2D);

                    for (int j = 0; j < dxffeature.getGeometry().pointNr(); j++) {

                        Point2D point = dxffeature.getGeometry().get(j);

                        polygon.addVertex(point.getX(), point.getY());

                    }

                    Point2D point = dxffeature.getGeometry().get(0);

                    polygon.addVertex(point.getX(), point.getY());

                    return polygon;

                }

            }

            return null;

        }

        private void addGeometryToFeature(Geometry geometry, FeatureProvider feature) {

            if( geometry != null ) {

                feature.set(ID_FIELD_GEOMETRY, geometry);

                feature.setDefaultGeometry(geometry);

                if (this.envelope == null) {

                    this.envelope = geometry.getEnvelope();

                } else {

                    this.envelope.add(geometry.getEnvelope());

                }

            }

        }

        private void addfeatureToLegend(FeatureProvider feature) {

            if (leyendBuilder != null) {

                try {

                    leyendBuilder.process(feature);

                } catch (Exception e) {

                    logger.warn(

                        MessageFormat.format(

                            "load: legendBuilder process fails in the feature {1}",

                            feature

                        )

                    );

                }

            }

        }

        /**

         * @throws DataException

         */

        public void load() throws DataException {

            this.envelope = null;

            IObjList.vector features = (IObjList.vector)featureMaker.getObjects();

            String acadVersion = headerManager.getAcadVersion();

            logger.info("load: acadVersion = '" + acadVersion + "'");

            GeometryManager gManager = GeometryLocator.getGeometryManager();

            if (!featureMaker.isDxf3DFile() && !headerManager.isWritedDxf3D()) {

                taskStatus.message("_fixing_3dgeometries");

                Feature[] features2D = new Feature[features.size()];

                taskStatus.setRangeOfValues(0,features.size());

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

                    taskStatus.setCurValue(i);

                    Feature fea = (Feature) features.get(i);

                    if (fea.getGeometry() instanceof org.gvsig.dxf.px.gml.Point3D) {

                        Point point = (Point) fea.getGeometry();

                        Point point2 = new Point();

                        for (int j = 0; j < point.pointNr(); j++) {

                            point2.add(point.get(j));

                        }

                        point2.setTextPoint(point.isTextPoint());

                        fea.setGeometry(point2);

                        features2D[i] = fea;

                    } else if (fea.getGeometry() instanceof LineString3D) {

                        LineString lineString = (LineString) fea.getGeometry();

                        LineString lineString2 = new LineString();

                        for (int j = 0; j < lineString.pointNr(); j++) {

                            lineString2.add(lineString.get(j));

                        }

                        fea.setGeometry(lineString2);

                        features2D[i] = fea;

                    } else if (fea.getGeometry() instanceof Polygon3D) {

                        Polygon polygon = (Polygon) fea.getGeometry();

                        Polygon polygon2 = new Polygon();

                        for (int j = 0; j < polygon.pointNr(); j++) {

                            polygon2.add(polygon.get(j));

                        }

                        fea.setGeometry(polygon2);

                        features2D[i] = fea;

                    }

                }

                features.clear();

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

                    features.add(features2D[i]);

                }

            }

            FilteredLogger logger = new FilteredLogger(DXFStoreProvider.logger,"DXFLoafing",20);

            FeatureType ft = store.getStoreServices().getDefaultFeatureType();

            taskStatus.message("_loading");

            // Nos recorremos las geometrias tres veces para cargarlas en orden:

            // - poligonos

            // - lineas

            // - puntos

            // Y garantizar que siempre se pinten los puntos sobre lineas y

            // poligonos y las lineas sobre los polignos.

            int n = 0;

            taskStatus.setRangeOfValues(0,features.size()*3);

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

                taskStatus.setCurValue(n++);

                try {

                    Feature dxffeature = (Feature) features.get(i);

                    FeatureProvider feature = createFeature(dxffeature, ft, i);

                    Geometry geometry = processPolygons(gManager, dxffeature);

                    if( geometry != null ) {

                        addGeometryToFeature(geometry, feature);

                        store.addFeatureProvider(feature);

                        addfeatureToLegend(feature);

                    }

                } catch (Exception e) {

                    logger.warn("Can't proccess feature '"+i+", of file '"+fileName+"'.", e);

                }

            }

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

                taskStatus.setCurValue(n++);

                try {

                    Feature dxffeature = (Feature) features.get(i);

                    FeatureProvider feature = createFeature(dxffeature, ft, i);

                    Geometry geometry = processLines(gManager, dxffeature);

                    if( geometry != null ) {

                        addGeometryToFeature(geometry, feature);

                        store.addFeatureProvider(feature);

                        addfeatureToLegend(feature);

                    }

                } catch (Exception e) {

                    logger.warn("Can't proccess feature '"+i+", of file '"+fileName+"'.", e);

                }

            }

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

                taskStatus.setCurValue(n++);

                try {

                    Feature dxffeature = (Feature) features.get(i);

                    FeatureProvider feature = createFeature(dxffeature, ft, i);

                    Geometry geometry = processPoints(gManager, dxffeature);

                    if( geometry != null ) {

                        addGeometryToFeature(geometry, feature);

                        store.addFeatureProvider(feature);

                        addfeatureToLegend(feature);

                    }

                } catch (Exception e) {

                    logger.warn("Can't proccess feature '"+i+", of file '"+fileName+"'.", e);

                }

            }

        }

    }

    /**

     * @author gvSIG team

     *

     */

    public class Writer {

        private Double DEFAULT_ELEVATION = new Double(0);

        private DxfFile.EntityFactory entityMaker;

        private IProjection proj = null;

        private int handle = 40; // Revisar porqu� es 40.

        private int k = 0;

        private boolean dxf3DFile = false;

        private String fileName;

        private Envelope envelope;

        /**

         * @param file

         * @param projection

         * @return the writer

         */

        public Writer initialice(File file, IProjection projection) {

            this.proj = projection;

            this.fileName = file.getAbsolutePath();

            entityMaker = new DxfEntityMaker(proj);

            return this;

        }

        /**

         *

         */

        public void begin() {

            envelope = null;

            entityMaker = new DxfEntityMaker(proj);

        }

        /**

         * @throws WriteException

         */

        public void end() throws WriteException {

            try {

                DxfFile dxfFile = new DxfFile(null, fileName, entityMaker);

                dxfFile.setCadFlag(true);

                if (dxf3DFile) {

                    dxfFile.setDxf3DFlag(true);

                }

                dxfFile.save(fileName);

                dxfFile.close();

            } catch (Exception e) {