Application: gvSIG desktop » gvSIG data provider for DGN

<?xml version="1.0" encoding="UTF-8"?>

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">

  <modelVersion>4.0.0</modelVersion>

  <artifactId>org.gvsig.dgn.app</artifactId>

  <packaging>pom</packaging>

  <name>${project.artifactId}</name>

  <parent>

      <groupId>org.gvsig</groupId>

      <artifactId>org.gvsig.dgn</artifactId>

      <version>2.0.260</version>

  </parent>

  <modules>

    <module>org.gvsig.dgn.app.mainplugin</module>

  </modules>

</project>

#Mon Aug 28 17:08:47 CEST 2023

buildNumber=2319

<?xml version="1.0" encoding="ISO-8859-1"?>

<plugin-config>

  <libraries library-dir="lib/"/>

  <depends plugin-name="org.gvsig.app.mainplugin"/>

  <resourceBundle name="text"/>

  <extensions>

     <extension class-name="org.gvsig.andami.LibraryExtension" active="false"/>

  </extensions>

</plugin-config>

<assembly>

  <id>gvsig-plugin-package</id>

  <formats>

    <format>zip</format>

  </formats>

  <baseDirectory>${project.artifactId}</baseDirectory>

  <includeBaseDirectory>true</includeBaseDirectory>

  <files>

    <file>

      <source>target/${project.artifactId}-${project.version}.jar</source>

      <outputDirectory>lib</outputDirectory>

    </file>

    <file>

      <source>target/package.info</source>

    </file>

  </files>

  <fileSets>

    <fileSet>

      <directory>src/main/resources-plugin</directory>

      <outputDirectory>.</outputDirectory>

    </fileSet>

  </fileSets>

  <dependencySets>

    <dependencySet>

      <useProjectArtifact>false</useProjectArtifact>

      <useTransitiveDependencies>false</useTransitiveDependencies>

      <outputDirectory>lib</outputDirectory>

      <includes>

        <include>org.gvsig:org.gvsig.dgn.provider.legend</include>

        <include>org.gvsig:org.gvsig.dgn.provider</include>

      </includes>

    </dependencySet>

  </dependencySets>

</assembly>

<?xml version="1.0" encoding="UTF-8"?>

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">

  <modelVersion>4.0.0</modelVersion>

  <artifactId>org.gvsig.dgn.app.mainplugin</artifactId>

  <packaging>jar</packaging>

  <name>${project.artifactId}</name>

  <description>DGN file format support</description>

  <parent>

      <groupId>org.gvsig</groupId>

      <artifactId>org.gvsig.dgn.app</artifactId>

      <version>2.0.260</version>

  </parent>

  <dependencies>

    <dependency>

        <groupId>org.gvsig</groupId>

        <artifactId>org.gvsig.tools.lib</artifactId>

        <scope>compile</scope>

    </dependency>

    <dependency>

        <groupId>org.gvsig</groupId>

        <artifactId>org.gvsig.andami</artifactId>

        <scope>compile</scope>

    </dependency>

    <dependency>

        <groupId>org.gvsig</groupId>

        <artifactId>org.gvsig.dgn.provider</artifactId>

        <scope>compile</scope>

    </dependency>

    <dependency>

        <groupId>org.gvsig</groupId>

        <artifactId>org.gvsig.dgn.provider.legend</artifactId>

        <scope>compile</scope>

    </dependency>

  </dependencies>

    <properties>

        <!-- Package info property values -->

        <!-- Default values in org.gvsig.desktop -->

        <gvsig.package.info.name>Formats: DGN file format support</gvsig.package.info.name>

        <gvsig.package.info.state>testing</gvsig.package.info.state>

        <gvsig.package.info.official>true</gvsig.package.info.official>

        <gvsig.package.info.dependencies>required: org.gvsig.app.mainplugin -ge 2.1.0-A</gvsig.package.info.dependencies>

        <gvsig.package.info.categories>Formats,Vector</gvsig.package.info.categories>

        <gvsig.package.info.poolURL>https://devel.gvsig.org/download/projects/gvsig-dgn/pool/</gvsig.package.info.poolURL>

    </properties>

</project>

<?xml version="1.0" encoding="UTF-8"?>

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">

  <modelVersion>4.0.0</modelVersion>

  <artifactId>org.gvsig.dgn.provider.legend</artifactId>

  <packaging>jar</packaging>

  <name>${project.artifactId}</name>

  <description>DAL provider for DGN files</description>

  <parent>

      <groupId>org.gvsig</groupId>

      <artifactId>org.gvsig.dgn</artifactId>

      <version>2.0.260</version>

  </parent>

  <dependencies>

    <dependency>

      <groupId>org.gvsig</groupId>

      <artifactId>org.gvsig.dgn.provider</artifactId>

      <scope>compile</scope>

    </dependency>

    <dependency>

      <groupId>commons-io</groupId>

      <artifactId>commons-io</artifactId>

      <scope>compile</scope>

    </dependency>

    <dependency>

        <groupId>org.gvsig</groupId>

        <artifactId>org.gvsig.tools.lib</artifactId>

        <scope>compile</scope>

    </dependency>

    <dependency>

        <groupId>org.gvsig</groupId>

        <artifactId>org.gvsig.projection.api</artifactId>

        <scope>compile</scope>

    </dependency>

    <dependency>

        <groupId>org.gvsig</groupId>

        <artifactId>org.gvsig.fmap.dal.api</artifactId>

        <scope>compile</scope>

    </dependency>

    <dependency>

        <groupId>org.gvsig</groupId>

        <artifactId>org.gvsig.fmap.dal.spi</artifactId>

        <scope>compile</scope>

    </dependency>

    <dependency>

        <groupId>org.gvsig</groupId>

        <artifactId>org.gvsig.metadata.lib.basic.api</artifactId>

        <scope>compile</scope>

    </dependency>

    <dependency>

        <groupId>org.gvsig</groupId>

        <artifactId>org.gvsig.fmap.geometry.api</artifactId>

        <scope>compile</scope>

    </dependency>

    <dependency>

        <groupId>org.gvsig</groupId>

        <artifactId>org.gvsig.fmap.mapcontext.api</artifactId>

        <scope>compile</scope>

    </dependency>

    <dependency>

        <groupId>org.gvsig</groupId>

        <artifactId>org.gvsig.symbology.lib.api</artifactId>

        <scope>compile</scope>

    </dependency>

    <dependency>

        <groupId>org.gvsig</groupId>

        <artifactId>org.gvsig.timesupport.lib.api</artifactId>

        <scope>compile</scope>

    </dependency>  

    <dependency>

      <groupId>org.gvsig</groupId>

      <artifactId>org.gvsig.utils</artifactId>

      <scope>compile</scope>

    </dependency>

    <!-- TESTS -->

    <dependency>

      <groupId>org.gvsig</groupId>

      <artifactId>org.gvsig.tools.lib</artifactId>

      <type>test-jar</type>

      <scope>test</scope>

    </dependency>

    <dependency>

      <groupId>org.gvsig</groupId>

      <artifactId>org.gvsig.compat.se</artifactId>

      <scope>test</scope>

    </dependency>

    <dependency>

      <groupId>org.gvsig</groupId>

      <artifactId>org.gvsig.fmap.dal.impl</artifactId>

      <scope>test</scope>

    </dependency>

    <!--

    <dependency>

      <groupId>org.gvsig</groupId>

      <artifactId>org.gvsig.fmap.geometry.generalpath</artifactId>

      <scope>test</scope>

    </dependency>

    -->

    <dependency>

      <groupId>org.gvsig</groupId>

      <artifactId>org.gvsig.projection.cresques.impl</artifactId>

      <scope>test</scope>

    </dependency>

    <dependency>

      <groupId>org.gvsig</groupId>

      <artifactId>org.gvsig.timesupport.lib.impl</artifactId>

      <scope>test</scope>

    </dependency>   

  </dependencies>

</project>

/* gvSIG. Geographic Information System of the Valencian Government

 *

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

 * of the Valencian Government (CIT)

 *

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

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

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

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

 *

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

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

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

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

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

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

 * MA  02110-1301, USA.

 *

 */

/*

* AUTHORS (In addition to CIT):

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

*/

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

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

import org.gvsig.fmap.dal.store.dgn.DGNStoreProvider;

import org.gvsig.fmap.dal.store.dgn.LegendBuilder;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dynobject.AbstractDynMethod;

import org.gvsig.tools.dynobject.DynClass;

import org.gvsig.tools.dynobject.DynObject;

import org.gvsig.tools.dynobject.DynObjectManager;

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

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

public class DGNGetLabeling extends AbstractDynMethod {

	private static int code = DynObjectManager.NULLCODE;

	static void register(DynClass DGNDynClass) {

		if (code != DynObjectManager.NULLCODE) {

			return;

		}

		code = ToolsLocator.getDynObjectManager().registerDynMethod(

			DGNDynClass, 

			new DGNGetLabeling()

		);

	}

        public DGNGetLabeling() {

            super(LegendBuilder.DYNMETHOD_GETLABELING_NAME,"DGN Labeling");

        }

        @Override

	public int getCode() throws DynMethodNotSupportedException {

		return code;

	}

        @Override

	public Object invoke(DynObject self, Object[] args)

			throws DynMethodException {

		try {

			return ((DGNStoreProvider) self).getLabeling();

		} catch (OpenException e) {

			//FIXME

			throw new RuntimeException(e);

		}

	}

}

/* gvSIG. Geographic Information System of the Valencian Government

 *

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

 * of the Valencian Government (CIT)

 *

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

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

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

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

 *

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

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

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

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

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

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

 * MA  02110-1301, USA.

 *

 */

/*

* AUTHORS (In addition to CIT):

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

*/

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

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

import org.gvsig.fmap.dal.store.dgn.DGNStoreProvider;

import org.gvsig.fmap.dal.store.dgn.LegendBuilder;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dynobject.AbstractDynMethod;

import org.gvsig.tools.dynobject.DynClass;

import org.gvsig.tools.dynobject.DynObject;

import org.gvsig.tools.dynobject.DynObjectManager;

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

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

public class DGNGetLegend extends AbstractDynMethod {

	private static int code = DynObjectManager.NULLCODE;

	static void register(DynClass DGNDynClass) {

		if (code != DynObjectManager.NULLCODE) {

			return;

		}

		code = ToolsLocator.getDynObjectManager().registerDynMethod(

			DGNDynClass, 

			new DGNGetLegend()

		);

	}

        public DGNGetLegend() {

            super(LegendBuilder.DYNMETHOD_GETLEGEND_NAME,"DGN Legend");

        }

        @Override

	public int getCode() throws DynMethodNotSupportedException {

		return code;

	}

        @Override

	public Object invoke(DynObject self, Object[] args)

			throws DynMethodException {

		try {

			return ((DGNStoreProvider) self).getLegend();

		} catch (OpenException e) {

			throw new RuntimeException(e);

		}

	}

}

/* gvSIG. Geographic Information System of the Valencian Government

 *

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

 * of the Valencian Government (CIT)

 *

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

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

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

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

 *

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

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

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

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

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

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

 * MA  02110-1301, USA.

 *

 */

/*

* AUTHORS (In addition to CIT):

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

*/

/**

 *

 */

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

import org.gvsig.fmap.dal.DALLibrary;

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

import org.gvsig.fmap.dal.store.dgn.DGNStoreProvider;

import org.gvsig.metadata.MetadataLibrary;

import org.gvsig.metadata.MetadataLocator;

import org.gvsig.tools.dynobject.DynClass;

import org.gvsig.tools.library.AbstractLibrary;

import org.gvsig.tools.library.LibraryException;

/**

 * @author jmvivo

 *

 */

public class DGNLegendLibrary extends AbstractLibrary {

    @Override

    public void doRegistration() {

        registerAsServiceOf(DALLibrary.class);

        require(DGNLibrary.class);

        require(MetadataLibrary.class);

    }

	@Override

	protected void doInitialize() throws LibraryException {

	}

	@Override

	protected void doPostInitialize() throws LibraryException {

		DynClass metadataDefinition = (DynClass) MetadataLocator.getMetadataManager()

			.getDefinition(DGNStoreProvider.METADATA_DEFINITION_NAME);

		DGNGetLegendBuilder.register(metadataDefinition);

		DGNGetLegend.register(metadataDefinition);

		DGNGetLabeling.register(metadataDefinition);

	}

}

/* gvSIG. Geographic Information System of the Valencian Government

 *

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

 * of the Valencian Government (CIT)

 *

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

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

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

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

 *

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

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

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

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

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

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

 * MA  02110-1301, USA.

 *

 */

/*

* AUTHORS (In addition to CIT):

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

*/

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

import org.gvsig.fmap.dal.store.dgn.LegendBuilder;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dynobject.AbstractDynMethod;

import org.gvsig.tools.dynobject.DynClass;

import org.gvsig.tools.dynobject.DynObject;

import org.gvsig.tools.dynobject.DynObjectManager;

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

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

public class DGNGetLegendBuilder extends AbstractDynMethod {

	private static int code = DynObjectManager.NULLCODE;

	static void register(DynClass DGNDynClass) {

		if (code != DynObjectManager.NULLCODE) {

			return;

		}

		code = ToolsLocator.getDynObjectManager().registerDynMethod(

			DGNDynClass, 

			new DGNGetLegendBuilder()

		);

	}

        public DGNGetLegendBuilder() {

            super(LegendBuilder.DYNMETHOD_BUILDER_NAME,"DGN LegendBuilder creator");

        }

        @Override

	public int getCode() throws DynMethodNotSupportedException {

		return code;

	}

        @Override

	public Object invoke(DynObject self, Object[] args)

			throws DynMethodException {

		return new DGNLegendBuilder();

	}

}

/* gvSIG. Geographic Information System of the Valencian Government

 *

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

 * of the Valencian Government (CIT)

 *

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

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

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

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

 *

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

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

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

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

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

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

 * MA  02110-1301, USA.

 *

 */

/*

* AUTHORS (In addition to CIT):

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

*/

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

import java.awt.Color;

import org.gvsig.fmap.dal.DataTypes;

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

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

import org.gvsig.fmap.dal.store.dgn.DGNStoreProvider;

import org.gvsig.fmap.dal.store.dgn.LegendBuilder;

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

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.mapcontext.MapContextLocator;

import org.gvsig.fmap.mapcontext.MapContextManager;

import org.gvsig.fmap.mapcontext.rendering.legend.IVectorialUniqueValueLegend;

import org.gvsig.fmap.mapcontext.rendering.symbols.ISymbol;

import org.gvsig.symbology.SymbologyLocator;

import org.gvsig.symbology.fmap.mapcontext.rendering.legend.styling.IAttrInTableLabelingStrategy;

import org.gvsig.symbology.fmap.mapcontext.rendering.symbol.fill.IFillSymbol;

import org.gvsig.symbology.fmap.mapcontext.rendering.symbol.line.ILineSymbol;

import org.gvsig.symbology.fmap.mapcontext.rendering.symbol.marker.IMarkerSymbol;

public class DGNLegendBuilder implements LegendBuilder {

	private MapContextManager mapContextManager = MapContextLocator

			.getMapContextManager();

	private IVectorialUniqueValueLegend defaultLegend = null;

	private IAttrInTableLabelingStrategy labelingStragegy = null;

	public void begin() {

		// Nothing to do

	}

	public void end() {

		// Nothing to do

	}

	public Object getLegend() {

		return defaultLegend;

	}

	public LegendBuilder initialize(FeatureStoreProvider store) {

		defaultLegend = (IVectorialUniqueValueLegend) mapContextManager.createLegend(

						IVectorialUniqueValueLegend.LEGEND_NAME);

		defaultLegend.setShapeType(Geometry.TYPES.GEOMETRY);

		defaultLegend

				.setClassifyingFieldNames(new String[] { DGNStoreProvider.NAME_FIELD_COLOR });

		defaultLegend.setClassifyingFieldTypes(new int[] { DataTypes.INT });

		ISymbol myDefaultSymbol =

				mapContextManager.getSymbolManager()

				.createSymbol(Geometry.TYPES.GEOMETRY);

		defaultLegend.setDefaultSymbol(myDefaultSymbol);

		labelingStragegy = SymbologyLocator.getSymbologyManager().createAttrInTableLabelingStrategy();

		labelingStragegy.setTextField(DGNStoreProvider.NAME_FIELD_TEXT);

		labelingStragegy

				.setRotationField(DGNStoreProvider.NAME_FIELD_ROTATIONTEXT);

		labelingStragegy.setHeightField(DGNStoreProvider.NAME_FIELD_HEIGHTTEXT);

		labelingStragegy.setUnit(1); // MapContext.NAMES[1] (meters)

		return this;

	}

	public void process(FeatureProvider feature, DGNReader dgnReader) {

		Integer clave = (Integer) feature.get("Color");

		if (clave == null) {

			return;

		}

		defaultLegend.useDefaultSymbol(false);

		if (defaultLegend.getSymbolByValue(clave) == null) {

			ISymbol theSymbol;

			Color color = dgnReader.DGNLookupColor(clave.intValue());

                        if( color == null ) {

                            color = Color.BLACK;

                        }

			theSymbol = mapContextManager.getSymbolManager().createSymbol(

					Geometry.TYPES.GEOMETRY, color);

			theSymbol.setDescription(clave.toString());

			if (theSymbol instanceof IMarkerSymbol) {

				((IMarkerSymbol) theSymbol).setSize(1);

			}

			if (theSymbol instanceof ILineSymbol) {

				ILineSymbol lineSymbol = (ILineSymbol) theSymbol;

				lineSymbol.setLineWidth(1);

				lineSymbol.setLineColor(color);

			}

			if (theSymbol instanceof IFillSymbol) {

				IFillSymbol fillSymbol = (IFillSymbol) theSymbol;

				fillSymbol.getOutline().setLineColor(color);

				fillSymbol.getOutline().setLineWidth(1);

				fillSymbol.setFillColor(null);

			}

			if (theSymbol != null) {

				defaultLegend.addSymbol(clave, theSymbol);

			}

		}

        defaultLegend.useDefaultSymbol(true);

	}

	public Object getLabeling() {

		return labelingStragegy;

	}

}

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

import java.util.ArrayList;

import java.util.HashMap;

import java.util.Iterator;

import java.util.List;

import java.util.Map;

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

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

import static org.gvsig.fmap.dal.store.dgn.DGNStoreProvider.GROUP_GEOMETRIES_CONVEXHULL;

import static org.gvsig.fmap.dal.store.dgn.DGNStoreProvider.GROUP_GEOMETRIES_INTERSECTION;

import static org.gvsig.fmap.dal.store.dgn.DGNStoreProvider.GROUP_GEOMETRIES_NONE;

import static org.gvsig.fmap.dal.store.dgn.DGNStoreProvider.GROUP_GEOMETRIES_TOLINES;

import static org.gvsig.fmap.dal.store.dgn.DGNStoreProvider.GROUP_GEOMETRIES_TOPOINTS;

import static org.gvsig.fmap.dal.store.dgn.DGNStoreProvider.GROUP_GEOMETRIES_TOPOLYGONS;

import static org.gvsig.fmap.dal.store.dgn.DGNStoreProvider.GROUP_GEOMETRIES_TOPOLYGONS_FIX;

import static org.gvsig.fmap.dal.store.dgn.DGNStoreProvider.GROUP_GEOMETRIES_UNION;

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

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.GeometryLocator;

import org.gvsig.fmap.geom.GeometryManager;

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

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

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

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

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

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

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

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

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

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

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

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

import org.gvsig.tools.logger.FilteredLogger;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

public class PostProcessGroupOperation {

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

    private int groupByFieldIndex = -1;

    private Map<Object, FeatureProvider> groupedFeatures = null;

    private GeometryManager geomManager = null;

    private int ID_FIELD_GEOMETRY = -1;

    private int MAX_FIELD_ID = -1;

    private int groupGeometriesOperation = -1;

    private Envelope envelope = null;

    public PostProcessGroupOperation(FeatureType featureType, String groupfield, int groupGeometriesOperation) {

        this.groupByFieldIndex = featureType.getIndex(groupfield);

        if (groupByFieldIndex < 0) {

            throw new IllegalArgumentException("Can't group by field '" + groupfield + ", the field don't exists.");

        }

        this.geomManager = GeometryLocator.getGeometryManager();

        this.ID_FIELD_GEOMETRY = featureType.getDefaultGeometryAttribute().getIndex();

        this.MAX_FIELD_ID = featureType.size() - 1;

        this.groupGeometriesOperation = groupGeometriesOperation;

    }

    public void add(FeatureProvider data) {

        if (groupedFeatures == null) {

            groupedFeatures = new HashMap<Object, FeatureProvider>();

        }

        Object groupbyValue = data.get(groupByFieldIndex);

        FeatureProvider group = groupedFeatures.get(groupbyValue);

        if (group == null) {

            groupedFeatures.put(groupbyValue, data);

            MultiPrimitive multi = getMultiPrimitive((Geometry) data.get(ID_FIELD_GEOMETRY));

            if (multi == null) {

                data.set(ID_FIELD_GEOMETRY, null);

            } else {

                data.set(ID_FIELD_GEOMETRY, multi);

            }

            return;

        }

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

            Object value = group.get(i);

            if (i == ID_FIELD_GEOMETRY) {

                Geometry newgeom = (Geometry) data.get(i);

                if (newgeom != null) {

                    if (value == null) {

                        group.set(ID_FIELD_GEOMETRY, getMultiPrimitive(newgeom));

                    } else {

                        try {

                            ((MultiPrimitive) value).addPrimitive((Primitive) newgeom);

                        } catch (Exception ex) {

                            logger.warn("Can't group geoemtry '" + newgeom.toString() + "' in '" + value.toString() + "'.", ex);

                        }

                    }

                }

            } else if (value == null) {

                group.set(i, data.get(i));

            } else if (value instanceof String) {

                String s = (String) value;

                if (s.trim().length() == 0) {

                    group.set(i, data.get(i));

                }

            }

        }

    }

    private MultiPrimitive getMultiPrimitive(Geometry geom) {

        if (geom == null) {

            return null;

        }

        if (geom instanceof MultiPrimitive) {

            return (MultiPrimitive) geom;

        }

        MultiPrimitive multi = null;

        try {

            if (geom instanceof Point) {

                multi = (MultiPrimitive) geomManager.create(

                        Geometry.TYPES.MULTIPOINT,

                        geom.getGeometryType().getSubType()

                );

            } else if (geom instanceof Curve) {

                multi = (MultiPrimitive) geomManager.create(

                        Geometry.TYPES.MULTICURVE,

                        geom.getGeometryType().getSubType()

                );

            } else if (geom instanceof Surface) {

                multi = (MultiPrimitive) geomManager.create(

                        Geometry.TYPES.MULTISURFACE,

                        geom.getGeometryType().getSubType()

                );

            }

            if (multi != null) {

                multi.addPrimitive((Primitive) geom);

            }

        } catch (CreateGeometryException ex) {

            logger.warn("Can't create multi-geometry to group", ex);

        }

        return multi;

    }

    public List<FeatureProvider> getRows() {

        if (this.groupGeometriesOperation < 0) {

            Iterator<FeatureProvider> rowsIterator = this.groupedFeatures.values().iterator();

            while( rowsIterator.hasNext() ) {

                FeatureProvider feature = rowsIterator.next();

                Geometry geometry = feature.getDefaultGeometry();

                if (geometry != null) {

                    if (this.envelope == null) {

                        this.envelope = geometry.getEnvelope();

                    } else {

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

                    }

                }

            }

            return (List<FeatureProvider>) this.groupedFeatures.values();

        }

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

        FilteredLogger log = new FilteredLogger(logger, "ConsolideGroupBy", 10);

        Iterator<Map.Entry<Object, FeatureProvider>> it = groupedFeatures.entrySet().iterator();

        while (it.hasNext()) {

            Map.Entry<Object, FeatureProvider> entry = it.next();

            String groupValue = "<null>";

            if (entry.getKey() != null) {

                groupValue = entry.getKey().toString();

            }

            try {

                FeatureProvider data = entry.getValue();

                Geometry geometry = data.getDefaultGeometry();

                if (geometry != null) {

                    switch (this.groupGeometriesOperation) {

                        case GROUP_GEOMETRIES_NONE:

                            break;

                        case GROUP_GEOMETRIES_CONVEXHULL:

                            try {

                                geometry = geometry.convexHull();

                                data.set(ID_FIELD_GEOMETRY, geometry);

                            } catch (Exception ex) {

                                log.warn("Can't create convex-hull with geometries of the group '" + groupValue + "'.", ex);

                            }

                            break;

                        case GROUP_GEOMETRIES_UNION:

                            if (geometry instanceof Aggregate) {

                                try {

                                    geometry = ((Aggregate) geometry).union();

                                    data.set(ID_FIELD_GEOMETRY, geometry);

                                } catch (Exception ex) {

                                    log.warn("Can't create a union with geometries of the group '" + groupValue + "'.", ex);

                                }

                            }

                            break;

                        case GROUP_GEOMETRIES_INTERSECTION:

                            if (geometry instanceof Aggregate) {

                                try {

                                    geometry = ((Aggregate) geometry).intersection();

                                    data.set(ID_FIELD_GEOMETRY, geometry);

                                } catch (Exception ex) {

                                    log.warn("Can't create a intersection with geometries of the group '" + groupValue + "'.", ex);

                                }

                            }

                            break;

                        case GROUP_GEOMETRIES_TOPOINTS:

                            try {

                                if (geometry instanceof Line) {

                                    geometry = ((Line) geometry).toPoints();

                                    data.set(ID_FIELD_GEOMETRY, geometry);

                                } else if (geometry instanceof Polygon) {

                                    geometry = ((Polygon) geometry).toPoints();

                                    data.set(ID_FIELD_GEOMETRY, geometry);

                                } else if (geometry instanceof Point) {

                                    geometry = ((Point) geometry).toPoints();

                                    data.set(ID_FIELD_GEOMETRY, geometry);

                                } else if (geometry instanceof MultiLine) {

                                    geometry = ((MultiLine) geometry).toPoints();

                                    data.set(ID_FIELD_GEOMETRY, geometry);

                                } else if (geometry instanceof MultiPolygon) {

                                    geometry = ((MultiPolygon) geometry).toPoints();

                                    data.set(ID_FIELD_GEOMETRY, geometry);

                                }

                            } catch (Exception ex) {

                                log.warn("Can't convert to points the geometries of the group '" + groupValue + "'.", ex);

                            }

                            break;

                        case GROUP_GEOMETRIES_TOLINES:

                            try {

                                if (geometry instanceof Polygon) {

                                    geometry = ((Polygon) geometry).toLines();

                                    data.set(ID_FIELD_GEOMETRY, geometry);

                                } else if (geometry instanceof MultiPolygon) {

                                    geometry = ((MultiPolygon) geometry).toLines();

                                    data.set(ID_FIELD_GEOMETRY, geometry);

                                }

                            } catch (Exception ex) {

                                log.warn("Can't convert to lines the geometries of the group '" + groupValue + "'.", ex);

                            }

                            break;

                        case GROUP_GEOMETRIES_TOPOLYGONS:

                            try {

                                if (geometry instanceof Line) {

                                    geometry = ((Line) geometry).toPolygons();

                                    data.set(ID_FIELD_GEOMETRY, geometry);

                                } else if (geometry instanceof MultiLine) {

                                    geometry = ((MultiLine) geometry).toPolygons();

                                    data.set(ID_FIELD_GEOMETRY, geometry);

                                } else {

                                    geometry = null;

                                    data.set(ID_FIELD_GEOMETRY, geometry);

                                }

                            } catch (Exception ex) {

                                log.warn("Can't convert to polygons the geometries of the group '" + groupValue + "'.", ex);

                            }

                            break;

                        case GROUP_GEOMETRIES_TOPOLYGONS_FIX:

                            try {

                                if (geometry instanceof Line) {

                                    geometry = ((Line) geometry).toPolygons();

                                    geometry = geometry.buffer(0);

                                    data.set(ID_FIELD_GEOMETRY, geometry);

                                } else if (geometry instanceof MultiLine) {

                                    geometry = ((MultiLine) geometry).toPolygons();

                                    geometry = geometry.buffer(0);

                                    data.set(ID_FIELD_GEOMETRY, geometry);

                                } else {

                                    geometry = null;

                                    data.set(ID_FIELD_GEOMETRY, geometry);

                                }

                            } catch (Exception ex) {

                                log.warn("Can't convert to polygons the geometries of the group '" + groupValue + "'.", ex);

                            }

                            break;

                    }

                    if (geometry != null) {

                        if (this.envelope == null) {

                            this.envelope = geometry.getEnvelope();

                        } else {

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

                        }

                    }

                }

                result.add(data);

            } catch (Exception ex) {

                log.warn("Problem adding data from group '" + groupValue + "'.", ex);

            }

        }

        return result;

    }

    public Envelope getEnvelope() {

        if( this.envelope == null ) {

        }

        return this.envelope;

    }

}

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

import java.util.ArrayList;

import java.util.Collections;

import java.util.Comparator;

import java.util.Iterator;

import java.util.List;

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

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

import org.gvsig.fmap.dal.store.dgn.DGNStoreProvider.TimeCounter;

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.GeometryLocator;

import org.gvsig.fmap.geom.GeometryManager;

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

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

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

public class PostProcessFeatures {

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

    private final FeatureType featureType;

    private final DGNOpenStoreParameters parameters;

    private Envelope envelope;

    private final int geomSubtype;

    private PostProcessFilterOperation filter = null;

    public PostProcessFeatures(DGNOpenStoreParameters parameters, FeatureType featureType) {

        this.featureType = featureType;

        this.parameters = parameters;

        if (parameters.ignoreZs()) {

            this.geomSubtype = Geometry.SUBTYPES.GEOM2D;

        } else {

            this.geomSubtype = featureType.getDefaultGeometryAttribute().getGeomType().getSubType();

        }

    }

    private DGNOpenStoreParameters getDGNParameters() {

        return this.parameters;

    }

    private PostProcessFilterOperation getFilter() {

        if (this.filter == null) {

            this.filter = new PostProcessFilterOperation(

                    getDGNParameters(),

                    featureType

            );

        }

        return this.filter;

    }

    public List<FeatureProvider> apply(List<FeatureProvider> rows) throws CreateEnvelopeException {

        TimeCounter tc_total = new TimeCounter();

        TimeCounter tc_accept = new TimeCounter();

        PostProcessFilterOperation filter = this.getFilter();

        List<FeatureProvider> result = null;

        Iterator<FeatureProvider> rowsIterator = rows.iterator();

        int rowCount = 0;

        int rowFitereds = 0;

        if (parameters.getGroupBy() == null) {

            GeometryManager geomManager = GeometryLocator.getGeometryManager();

            this.envelope = geomManager.createEnvelope(this.geomSubtype);

            tc_total.start();

            result = new ArrayList<FeatureProvider>();

            while (rowsIterator.hasNext()) {

                FeatureProvider feature = rowsIterator.next();

                rowCount++;

                tc_accept.start();

                boolean accept = filter.accept(feature);

                tc_accept.stop();

                if (!accept) {

                    continue;

                }

                rowFitereds++;

                Geometry geom = feature.getDefaultGeometry();

                if (geom != null) {

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

                }

                result.add(feature);

            }

            tc_total.stop();

            tc_accept.log("Accepts time filter");

            tc_total.log("Total time filer, rows input "+rowCount+", output "+rowFitereds );

        } else {

            tc_total.start();

            PostProcessGroupOperation groupOperation = new PostProcessGroupOperation(

                    this.featureType,

                    parameters.getGroupBy(),

                    parameters.getGroupGeometriesOperation()

            );

            while (rowsIterator.hasNext()) {

                FeatureProvider feature = rowsIterator.next();

                rowCount++;

                tc_accept.start();

                boolean accept = filter.accept(feature);

                tc_accept.stop();

                if (!accept) {

                    continue;

                }

                rowFitereds++;

                groupOperation.add(feature);

            }

            result = groupOperation.getRows();

            this.envelope = groupOperation.getEnvelope();

            tc_total.stop();

            tc_accept.log("Accepts time filter+group");

            tc_total.log("Total time filer+group, rows input "+rowCount+", output "+rowFitereds );

        }

        if (parameters.sortByGeometryType()) {

            this.sortRows(result);

        }

        return result;

    }

    public Envelope getEnvelope() {

        return this.envelope;

    }

    private void sortRows(List<FeatureProvider> rows) {

        TimeCounter tc = new TimeCounter();

        tc.start();

        Collections.sort(rows, new Comparator<FeatureProvider>() {

            public int compare(FeatureProvider o1, FeatureProvider o2) {

                Geometry g1 = o1.getDefaultGeometry();

                Geometry g2 = o2.getDefaultGeometry();

                if (g1 == null) {

                    if (g2 == null) {

                        return 0;

                    } else {

                        return -1;

                    }

                } else if (g2 == null) {

                    return 1;

                }

                return g2.getType() - g1.getType();

            }

        });

        tc.stop();

        tc.log("sort data, rows "+rows.size());

    }

    public boolean hasOperations() {

        PostProcessFilterOperation filter = this.getFilter();

        if (filter.hasFilter()) {

            return true;

        }

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

            return true;

        }

        return false;

    }

}

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

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

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

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

public interface LegendBuilder {

	final public static String DYNMETHOD_BUILDER_NAME = "getLegendBuilder";

	final public static String DYNMETHOD_GETLEGEND_NAME = "getLegend";

	final public static String DYNMETHOD_GETLABELING_NAME = "getLabeling";

	public LegendBuilder initialize(FeatureStoreProvider store);

	public void begin();

	public void process(FeatureProvider feature, DGNReader dgnReader);

	public void end();

	public Object getLegend();

	public Object getLabeling();

}

/*

 * Created on 07-jul-2004

 *

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

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

 */

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

 *

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

 *

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

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

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

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

 *

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

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

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

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

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

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

 *

 */

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

/**

 * Clase utilizada para guardar un elemento de tipo Group.

 *

 * @author FJP

 */

public class DGNElemGroup extends DGNElemCore {

	/*                 typedef struct

	   {

	   Elm_hdr ehdr; // element header

	   Disp_hdr dhdr; // display header

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

	   char file_spec[65] //file specification

	   byte file_num; // file number

	   Fb_opts fb_opts; // file builder options mask

	   Fd_opts fd_opts; // file displayer options mask

	   byte disp_flags[16]; // display flags

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

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

	   double trns_mtrx[9]; // transformation matrix

	   double cnvrs_fact; // conversion factor

	   Group Data Elements (Type 5)

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

	   short log_chars; // characters in logical name

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

	   short desc_chars; // characters in description

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

	   short lev_sym_mask; // level symbology enable mask

	   short lev_sym[63]; // level symbology descriptor

	   long z_delta; // Z-direction delta

	   short clip_vertices; // clipping vertices

	   Point2d clip_poly[1]; // clipping polygon

	   } Ref_file_type5; */

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

	public double primary_axis;

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

	public double secondary_axis;

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

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

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

	public double startang;

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

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

        public DGNElemGroup(DGNReader dgnreader) {

            super(dgnreader);

        }

}

/**

 * gvSIG. Desktop Geographic Information System.

 *

 * Copyright (C) 2007-2013 gvSIG Association.

 *

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

 * the terms of the GNU General Public License as published by the Free Software

 * Foundation; either version 3 of the License, or (at your option) any later

 * version.

 *

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

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS

 * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more

 * details.

 *

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

 * this program; if not, write to the Free Software Foundation, Inc., 51

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

 *

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

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

 */

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

import java.awt.Color;

import java.awt.geom.Rectangle2D;

import java.io.FileInputStream;

import java.io.FileNotFoundException;

import java.nio.ByteBuffer;

import java.nio.ByteOrder;

import java.nio.MappedByteBuffer;

import java.nio.channels.FileChannel;

import java.text.MessageFormat;

import java.util.ArrayList;

import java.util.Formatter;

import java.util.Iterator;

import java.util.LinkedHashMap;

import java.util.List;

import java.util.Map;

import java.util.regex.Pattern;

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

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

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 * Clase dedicada a leer del fichero DGN.

 *

 */

public class DGNReader {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    {28, 0, 100}};

    private int LSB;

    private FileInputStream fin;

    // private LEDataInputStream input;

    private MappedByteBuffer bb;

    private int FALSE = 0;

    private int TRUE = 1;

    private DGNElemCore elemento;

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

    private Rectangle2D.Double m_BoundingBox;

    private DGNElemColorTable m_colorTable;

    private boolean logErrors = false;

    public DGNReader(String pathFich) throws DataException {

        this(pathFich, false);

    }

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

        this.logErrors = logErrors;

        info = new DGNInfo();

        DGNElemCore elemento = new DGNElemCore(this);

        int iArg;

        int bReportExtents = 0;

        byte[] achRaw = new byte[64];

        achRaw[63] = 1;

        double dfSFXMin = 0.0;

        double dfSFXMax = 0.0;

        double dfSFYMin = 0.0;

        double dfSFYMax = 0.0;

        info.fp = pathFich;