Application: gvSIG desktop » gvSIG data provider for DWG

import org.gvsig.fmap.geom.aggregate.MultiLine;

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

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

    private static final GeometryManager gManager = GeometryLocator

            .getGeometryManager();

    public static MultiCurve ptsToMultiLine(List<double[]> pts, int subType)

            throws CreateGeometryException {

        if (pts.size() < 2) {

            throw new IllegalArgumentException();

        }

        Point point, prevPoint;

        Line line;

        MultiLine multi = gManager.createMultiLine(subType);

        prevPoint = FMapUtil.createPoint(subType, pts.get(0));

        for (int i = 1; i < pts.size(); i++) {

            point = FMapUtil.createPoint(subType, pts.get(i));

            line = gManager.createLine(subType);

            line.addVertex(prevPoint);

            line.addVertex(point);

            multi.addPrimitive(line);

            prevPoint = FMapUtil.createPoint(subType, pts.get(i));

        }

        return multi;

    }

    public static Surface ptsToPolygon(List<double[]> pts, int subType)

            throws CreateGeometryException {

        if (pts.size() < 3) {

            throw new IllegalArgumentException();

        }

        Polygon polygon = gManager.createPolygon(subType);

        Iterator<double[]> iter = pts.iterator();

        while (iter.hasNext()) {

            Point vertex = createPoint(subType, iter.next());

            polygon.addVertex(vertex);

        }

        return polygon;

    }

    public static Point createPoint(int subType, double[] point) throws CreateGeometryException {

        Point result = gManager.createPoint(point[0], point[1], subType);

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

            result.setCoordinateAt(Geometry.DIMENSIONS.Z, point[2]);

        }

        return result;

    }

    public static Point createPoint(int subType, Point2D point) throws CreateGeometryException {

        Point result = gManager.createPoint(point.getX(), point.getY(), subType);

        return result;

    }

    public static Point createPoint(int subType, IDwgVertex dwgvertex) throws CreateGeometryException {

        double[] point = dwgvertex.getPoint();

        Point result = gManager.createPoint(point[0], point[1], subType);

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

            result.setCoordinateAt(Geometry.DIMENSIONS.Z, point[2]);

        }

        return result;

    }

    /**

     * Devuelve la distancia desde angle1 a angle2. Angulo en radianes de

     * diferencia entre angle1 y angle2 en sentido antihorario

     *

     * @param angle1 angulo en radianes. Debe ser positivo y no dar ninguna

     * vuelta a la circunferencia

     * @param angle2 angulo en radianes. Debe ser positivo y no dar ninguna

     * vuelta a la circunferencia

     *

     * @return distancia entre los �ngulos

     */

    public static double angleDistance(double angle1, double angle2) {

        if (angle1 < angle2) {

            return angle2 - angle1;

        } else {

            return ((Math.PI * 2) - angle1) + angle2;

        }

    }

		return FMapUtil.ptsToMultiLine(getPts(), getGeometrySubType(is3DFile));

		return FMapUtil.ptsToMultiLine(getPts(), getGeometrySubType(is3DFile));

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

                Line line;

                if( is3DFile ) {

                    line = gMan.createLine(Geometry.SUBTYPES.GEOM3D);

                    line.addVertex(p1[0],p1[1],p1[2]);

                    line.addVertex(p2[0],p2[1],p2[2]);

                } else {

                    line = gMan.createLine(Geometry.SUBTYPES.GEOM2D);

                    line.addVertex(p1[0],p1[1]);

                    line.addVertex(p2[0],p2[1]);

                }

                return line;

		return FMapUtil.ptsToMultiLine(getVertices(),

        ResourceConsumer {

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

    public static final String NAME = "DWG";

    public static final String DESCRIPTION = "DWG 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 int ID_FIELD_ID = 0;

    private int ID_FIELD_GEOMETRY = 1;

    private int ID_FIELD_ENTITY = 2;

    private int ID_FIELD_LAYER = 3;

    private int ID_FIELD_COLOR = 4;

    private int ID_FIELD_ELEVATION = 5;

    private int ID_FIELD_THICKNESS = 6;

    private int ID_FIELD_TEXT = 7;

    private int ID_FIELD_HEIGHTTEXT = 8;

    private int ID_FIELD_ROTATIONTEXT = 9;

    private IProjection projection;

    private ResourceProvider resource;

    private LegendBuilder legendBuilder;

    private long counterNewsOIDs = 0;

    protected GeometryManager geomManager = GeometryLocator.getGeometryManager();

    public DWGStoreProvider(DWGStoreParameters parameters,

            DataStoreProviderServices storeServices) throws InitializeException {

        super(parameters, storeServices, FileHelper

                .newMetadataContainer(METADATA_DEFINITION_NAME));

        counterNewsOIDs = 0;

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

        File file = getDWGParameters().getFile();

        resource = this.createResource(

                FileResource.NAME,

                new Object[]{file.getAbsolutePath()}

        );

        resource.addConsumer(this);

        this.projection = this.getDWGParameters().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 DWGStoreParameters getDWGParameters() {

        return (DWGStoreParameters) this.getParameters();

    }

    public String getProviderName() {

        return NAME;

    }

    public boolean allowWrite() {

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

        public ArrayList data = null;

        public FeatureType defaultFType = null;

        public List fTypes = null;

        public Envelope envelope = null;

        public IProjection projection;

        public LegendBuilder legendBuilder = null;

        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;

        }

    }

    private AbstractMemoryStoreProvider getStoreProvider() {

        return this;

    }

    public void open() throws OpenException {

        if (this.data != null) {

            return;

        }

        // this.resource.begin();

        // } catch (ResourceExecuteException e2) {

        // try {

        // throw new OpenException(resource.getName(), e2);

        // } catch (AccessResourceException e1) {

        // throw new OpenException(this.getName(), e2);

        // }

        //

        // }

        try {

            getResource().execute(new ResourceAction() {

                public Object run() throws Exception {

                    ResourceProvider resource = getResource();

                    DWGData dwgData = null;

                    FeatureStoreProviderServices store = getStoreServices();

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

                        dwgData

                                = (DWGData) ((Map) resource.getData()).get(projection.getAbrev());

                        // reproyeccion)

                    } else {

                        resource.setData(new HashMap());

                    }

                    if (dwgData == null) {

                        dwgData = new DWGData();

                        dwgData.data = new ArrayList();

                        data = dwgData.data;

                        counterNewsOIDs = 0;

                        Reader reader

                                = new Reader().initialice(getStoreProvider(),

                                        (File) resource.get(),

                                        projection, legendBuilder);

                        reader.begin(store);

                        dwgData.defaultFType

                                = reader.getDefaultType().getNotEditableCopy();

                        ArrayList types = new ArrayList();

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

                        EditableFeatureType fType;

                        while (it.hasNext()) {

                            fType = (EditableFeatureType) it.next();

                            if (fType.getId().equals(

                                    dwgData.defaultFType.getId())) {

                                types.add(dwgData.defaultFType);

                            } else {

                                types.add(fType.getNotEditableCopy());

                            }

                        }

                        dwgData.fTypes = types;

                        dwgData.legendBuilder = legendBuilder;

                        resource.notifyOpen();

                        store.setFeatureTypes(dwgData.fTypes,

                                dwgData.defaultFType);

                        reader.load();

                        // this.envelope = reader.getEnvelope();

                        dwgData.envelope = reader.getEnvelope();

                        dwgData.projection = projection;

                        reader.end();

                        resource.notifyClose();

                        ((Map) resource.getData()).put(projection.getAbrev(),

                                dwgData); // OJO la reproyeccion

                    }

                    data = dwgData.data;

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

                    legendBuilder = dwgData.legendBuilder;

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

                    setDynValue("CRS", projection);

                    counterNewsOIDs = data.size();

                    return null;

                }

            });

        } catch (Exception e) {

            this.data = null;

            try {

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

            } catch (AccessResourceException e1) {

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

            }

            // this.resource.end();

        }

    }

    public DataServerExplorer getExplorer() throws ReadException {

        DataManager manager = DALLocator.getDataManager();

        FilesystemServerExplorerParameters params;

        try {

            params = (FilesystemServerExplorerParameters) manager

                    .createServerExplorerParameters(FilesystemServerExplorer.NAME);

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

            return manager.createServerExplorer(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 class Reader {

        private File file;

        private String fileName;

        private IProjection projection;

        private List types;

        private LegendBuilder leyendBuilder;

        private AbstractMemoryStoreProvider store;

        private Envelope envelope;

        private DwgFile dwgFeatureFile;

        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;

        }

        public Envelope getEnvelope() {

            return this.envelope;

        }

        public void begin(FeatureStoreProviderServices store) throws UnsupportedDWGVersionException, ReadException {

            dwgFeatureFile = new DwgFile(file.getAbsolutePath());

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

            featureType.setHasOID(true);

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

                    .setDefaultValue(Integer.valueOf(0))

                    .getIndex();

            EditableFeatureAttributeDescriptor attr = featureType.add(

                    NAME_FIELD_GEOMETRY, DataTypes.GEOMETRY);

            attr.setSRS(this.projection);

            attr.setGeometryType(Geometry.TYPES.GEOMETRY);

            boolean is3dFile = dwgFeatureFile.isDwg3DFile();

            if (is3dFile) {

                attr.setGeometrySubType(Geometry.SUBTYPES.GEOM3D);

            } else {

                attr.setGeometrySubType(Geometry.SUBTYPES.GEOM2D);

            }

            ID_FIELD_GEOMETRY = attr.getIndex();

            featureType.setDefaultGeometryAttributeName(NAME_FIELD_GEOMETRY);

            // 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_LAYER = featureType.add(NAME_FIELD_LAYER,

                    DataTypes.STRING, 100)

                    .setDefaultValue(

                            "default").getIndex();

            ID_FIELD_COLOR = featureType.add(NAME_FIELD_COLOR,

                    DataTypes.INT)

                    .setDefaultValue(

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

            ID_FIELD_ELEVATION = featureType.add(NAME_FIELD_ELEVATION,

                    DataTypes.DOUBLE)

                    .setDefaultValue(

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

            ID_FIELD_THICKNESS = featureType.add(NAME_FIELD_THICKNESS,

                    DataTypes.DOUBLE)

                    .setDefaultValue(

                            Double.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_ROTATIONTEXT = featureType.add(NAME_FIELD_ROTATIONTEXT,

                    DataTypes.DOUBLE).setDefaultValue(

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

            // Habria que ver de pillarlos ?

            types = new ArrayList();

            types.add(featureType);

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

        }

        private Double toDouble(String value) {

            if (value == null) {

                return Double.valueOf(0);

            }

            return Double.valueOf(value);

        }

        public void load() throws DataException {

            this.envelope = null;

            dwgFeatureFile.calculateGisModelDwgPolylines();

            dwgFeatureFile.blockManagement2();

            List entities = dwgFeatureFile.getDwgObjects();

            int id = -1;

            try {

                int envelopeSubType = Geometry.SUBTYPES.GEOM2D;

                boolean is3dFile = dwgFeatureFile.isDwg3DFile();

                this.envelope = geomManager.createEnvelope(envelopeSubType);

                boolean updateEnvelope = true;

                double[] extMin = (double[]) dwgFeatureFile

                        .getHeader("MSPACE_EXTMIN");

                double[] extMax = (double[]) dwgFeatureFile

                        .getHeader("MSPACE_EXTMAX");

                if (extMin != null && extMax != null) {

                    updateEnvelope = false;

                    Point point = (Point) geomManager.create(

                            Geometry.TYPES.POINT, envelopeSubType);

                    point.setCoordinates(extMin);

                    this.envelope.setLowerCorner(point);

                    point = (Point) geomManager.create(Geometry.TYPES.POINT,

                            envelopeSubType);

                    point.setCoordinates(extMax);

                    this.envelope.setUpperCorner(point);

                }

                Iterator iter = entities.iterator();

                FeatureProvider featureProvider;

                Envelope gEnvelope;

                while (iter.hasNext()) {

                    id++;

                    DwgObject entity = (DwgObject) iter.next();

                    if (!(entity instanceof IDwg2FMap)) {

                        count_not_fmap_interface++;

                        /*

                         logger.warn("load: entity type {}(id:{}) not loadded",

                         new Object[] { entity.getType() }, id);

                         */

                        continue;

                    }

                    IDwg2FMap dwgEnt = (IDwg2FMap) entity;

                    Geometry geometry = dwgEnt.toFMapGeometry(is3dFile);

                    if (geometry == null) {

                        count_null_geometry++;

                        /*

                         logger.warn("load: entity {}(id:{}) with null geometry",

                         new Object[] { entity.getType(), id });

                         */

                        continue;

                    }

                    // creado correctamente

                    gEnvelope = null;

                    try {

                        gEnvelope = geometry.getEnvelope();

                    } catch (Exception e) {

                        gEnvelope = null;

                    }

                    if (gEnvelope == null) {

                        count_bad_envelope++;

                        /*

                         logger.warn("load: entity {}(id:{}) with null envelope",

                         new Object[] { entity.getType(), id });

                         */

                        continue;

                    }

                    // we check for Region of Interest of the CAD file

                    if (!this.envelope.intersects(geometry.getEnvelope())) {

                        count_envelope_out_of_aoi++;

                        /*

                         logger.warn("load: entity {}(id:{}) out of envelope",

                         new Object[] { entity.getType(), id });

                         */

                        continue;

                    }

                    featureProvider = store.createFeatureProvider(store

                            .getStoreServices().getDefaultFeatureType());

                    featureProvider.set(ID_FIELD_ID, id);

                    featureProvider.set(ID_FIELD_ENTITY, dwgEnt.toString());

                    featureProvider.set(ID_FIELD_LAYER, dwgFeatureFile

                            .getLayerName(entity));

                    int colorByLayer = dwgFeatureFile.getColorByLayer(entity);

                    int color = entity.getColor();

                    if (color < 0) {

                        color = Math.abs(color);

                    }

                    if (color > 255) {

                        color = colorByLayer;

                    }

                    featureProvider.set(ID_FIELD_COLOR, color);

                    if (entity instanceof IDwg3DTestable) {

                        featureProvider.set(ID_FIELD_ELEVATION,

                                ((IDwg3DTestable) entity).getZ());

                    }

                    featureProvider.set(ID_FIELD_THICKNESS, 0.0);

                    featureProvider.set(ID_FIELD_HEIGHTTEXT, 0.0);

                    featureProvider.set(ID_FIELD_ROTATIONTEXT, 0.0);

                    featureProvider.set(ID_FIELD_TEXT, "");

                    if (entity instanceof DwgMText) {

                        DwgMText mtext = (DwgMText) entity;

                        featureProvider.set(ID_FIELD_HEIGHTTEXT, mtext.getHeight());

                        featureProvider.set(ID_FIELD_TEXT, mtext.getText());

                    } else if (entity instanceof DwgText) {

                        DwgText text = (DwgText) entity;

                        featureProvider

                                .set(ID_FIELD_THICKNESS, text.getThickness());

                        featureProvider.set(ID_FIELD_HEIGHTTEXT, text.getHeight());

                        featureProvider.set(ID_FIELD_ROTATIONTEXT, text

                                .getRotationAngle());

                        featureProvider.set(ID_FIELD_TEXT, text.getText());

                    }// if-else

                    featureProvider.setDefaultGeometry(geometry);

                    store.addFeatureProvider(featureProvider);

                    if (this.leyendBuilder != null) {

                        this.leyendBuilder.process(featureProvider);

                    }

                }

                logger.info("Issues while loading DWG entities:+\n"

                        + "    Entities not implementing IDwg2FMap interface: " + count_not_fmap_interface + "\n"

                        + "    Entities with non-convertible geometry: " + count_null_geometry + "\n"

                        + "    Entities without valid envelope: " + count_bad_envelope + "\n"

                        + "    Entities with envelope out of global envelope: " + count_envelope_out_of_aoi);

            } catch (org.gvsig.fmap.geom.exception.CreateGeometryException e) {

                throw new CreateGeometryException(e);

            } catch (org.gvsig.fmap.geom.exception.CreateEnvelopeException e) {

                throw new CreateGeometryException(e);

            }

        }

    }

    public boolean closeResourceRequested(ResourceProvider resource) {

        return true;

    }

    public int getOIDType() {

        return DataTypes.LONG;

    }

    public boolean supportsAppendMode() {

        return false;

    }

    public void append(FeatureProvider featureProvider) {

        // FIXME Exception

        throw new UnsupportedOperationException();

    }

    public void beginAppend() {

        // FIXME Exception

        throw new UnsupportedOperationException();

    }

    public void endAppend() {

        // FIXME Exception

        throw new UnsupportedOperationException();

    }

    public void saveToState(PersistentState state) throws PersistenceException {

        // TODO Auto-generated method stub

        throw new NotYetImplemented();

    }

    public void loadFromState(PersistentState state) throws PersistenceException {

        // TODO Auto-generated method stub

        throw new NotYetImplemented();

    }

    public Object createNewOID() {

        return new Long(counterNewsOIDs++);

    }

    protected void initializeFeatureTypes() throws InitializeException {

        try {

            this.open();

        } catch (OpenException e) {

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

        }

    }

    public Envelope getEnvelope() throws DataException {

        this.open();

        return (Envelope) this.getDynValue("Envelope");

    }

    /*

     * (non-Javadoc)

     *

     * @see

     * org.gvsig.fmap.dal.resource.spi.ResourceConsumer#resourceChanged(org.

     * gvsig.fmap.dal.resource.spi.ResourceProvider)

     */

    public void resourceChanged(ResourceProvider resource) {

        this.getStoreServices().notifyChange(

                DataStoreNotification.RESOURCE_CHANGED,

                resource);

    }

    public Object getSourceId() {

        return this.getDWGParameters().getFile();

    }

    public String getName() {

        String name = this.getDWGParameters().getFile().getName();

        int n = name.lastIndexOf(".");

        if (n < 1) {

            return name;

        }

        return name.substring(0, n);

    }

    public String getFullName() {

        return this.getDWGParameters().getFile().getAbsolutePath();

    }

    public ResourceProvider getResource() {

        return resource;

    }

}