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</artifactId>

  <packaging>pom</packaging>

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

  <version>2.0.89</version>

  <description>DGN support fort DAL and gvSIG</description>

  <parent>

      <groupId>org.gvsig</groupId>

      <artifactId>org.gvsig.desktop</artifactId>

      <version>2.0.204</version>

  </parent>

  <url>https://devel.gvsig.org/redmine/projects/gvsig-dgn</url>

  <scm>

      <connection>scm:svn:https://devel.gvsig.org/svn/gvsig-dgn/org.gvsig.dgn/tags/org.gvsig.dgn-2.0.89</connection>

      <developerConnection>scm:svn:https://devel.gvsig.org/svn/gvsig-dgn/org.gvsig.dgn/tags/org.gvsig.dgn-2.0.89</developerConnection>

      <url>https://devel.gvsig.org/redmine/projects/gvsig-dgn/repository/show/org.gvsig.dgn/tags/org.gvsig.dgn-2.0.89</url>

  </scm>

    <repositories>

      <repository>

        <id>gvsig-public-http-repository</id>

        <name>gvSIG maven public HTTP repository</name>

        <url>http://devel.gvsig.org/m2repo/j2se</url>

        <releases>

          <enabled>true</enabled>

          <updatePolicy>daily</updatePolicy>

          <checksumPolicy>warn</checksumPolicy>

        </releases>

        <snapshots>

          <enabled>true</enabled>

          <updatePolicy>daily</updatePolicy>

          <checksumPolicy>warn</checksumPolicy>

        </snapshots>

      </repository>

    </repositories>

	<build>

		<plugins>

			<plugin>

				<groupId>org.apache.maven.plugins</groupId>

				<artifactId>maven-release-plugin</artifactId>

				<configuration>

					<tagBase>https://devel.gvsig.org/svn/gvsig-dgn/org.gvsig.dgn/tags</tagBase>

				</configuration>

			</plugin>

		</plugins>

	</build>

  <dependencyManagement>

      <dependencies>

          <dependency>

            <groupId>org.gvsig</groupId>

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

            <version>2.0.89</version>

          </dependency>

          <dependency>

            <groupId>org.gvsig</groupId>

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

            <version>2.0.89</version>

          </dependency>

          <dependency>

            <groupId>org.gvsig</groupId>

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

            <version>2.0.89</version>

          </dependency>

      </dependencies>

  </dependencyManagement>

  <dependencies>

        <dependency>

            <groupId>org.slf4j</groupId>

            <artifactId>slf4j-api</artifactId>

            <scope>compile</scope>

        </dependency>

  </dependencies>

  <modules>

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

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

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

  </modules>

</project>

<?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.89</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>

#Fri Sep 22 10:41:24 CEST 2017

buildNumber=2147

<?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.89</version>

  </parent>

  <modules>

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

  </modules>

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

			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;

	}

}

<?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.89</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;

import java.io.File;

import java.net.URL;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataManager;

import org.gvsig.fmap.dal.DataStoreParameters;

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

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

import org.gvsig.tools.junit.AbstractLibraryAutoInitTestCase;

import static junit.framework.Assert.assertNotNull;

public class TestDGN extends AbstractLibraryAutoInitTestCase {

	private File file_prueba = null;

        private DataManager dataManager = null;

        @Override

        protected void doSetUp() throws Exception {

            URL res = TestDGN.class.getResource("data/prueba.dgn");

            this.file_prueba = new File(res.getFile());

            this.dataManager = DALLocator.getDataManager();

        }

	/*

	 * (non-Javadoc)

	 *

	 * @see

	 * org.gvsig.fmap.dal.feature.BaseTestFeatureStore#getDefaultDataStoreParameters

	 * ()

	 */

	public DataStoreParameters getDefaultDataStoreParameters()

			throws DataException {

		DGNOpenStoreParameters dgnParameters = null;

		dgnParameters = (DGNOpenStoreParameters) dataManager

				.createStoreParameters(DGNStoreProvider.NAME);

		dgnParameters.setFile(file_prueba.getAbsolutePath());

		dgnParameters.setCRS("EPSG:23030");

		return dgnParameters;

	}

	/*

	 * (non-Javadoc)

	 *

	 * @see org.gvsig.fmap.dal.feature.BaseTestFeatureStore#hasExplorer()

	 */

	public boolean hasExplorer() {

		// TODO Auto-generated method stub

		return false;

	}

	public boolean usesResources() {

		return true;

	}

	public void testLegendAndLabeling() throws Exception {

		FeatureStore store = (FeatureStore) dataManager.openStore(

                        DGNStoreProvider.NAME,

                        getDefaultDataStoreParameters()

                );

		assertNotNull(store.invokeDynMethod("getLegend", null));

		assertNotNull(store.invokeDynMethod("getLabeling", null));

		store.dispose();

	}

}

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

import java.io.File;

import java.util.regex.Pattern;

import org.apache.commons.lang3.StringUtils;

import org.cresques.cts.IProjection;

import org.gvsig.fmap.dal.FileHelper;

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

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

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.fmap.geom.Geometry;

import org.gvsig.tools.dynobject.DelegatedDynObject;

public class DGNOpenStoreParameters extends AbstractDataParameters implements

        FilesystemStoreParameters,

        OpenFeatureStoreParameters {

    public static final String PARAMETERS_DEFINITION_NAME = "DGN";

    private static final String FIELD_FILE = "file";

    private static final String FIELD_CRS = "CRS";

    private static final String FIELD_XMLFILE = "XMLFile";

    private static final String FIELD_LOAD_MODE = "LoadMode";

    private static final String FIELD_RELOAD = "Reload";

    private static final String FIELD_GEOMTYPE_FILTER = "geomtypeFilter";

    private static final String FIELD_LEVEL_FILTER = "levelFilter";

    private static final String FIELD_TEXT_FILTER = "textFilter";

    private static final String FIELD_COLOR_FILTER = "colorFilter";

    private static final String FIELD_STYLE_FILTER = "styleFilter";

    private static final String FIELD_WEIGHT_FILTER = "weightFilter";

    private static final String FIELD_TYPE_FILTER = "typeFilter";

    private static final String FIELD_STYPE_FILTER = "stypeFilter";

    private static final String FIELD_GROUP_FILTER = "groupFilter";

    private static final String FIELD_ID_FILTER = "idFilter";

    private static final String FIELD_CROP_FILTER = "cropFilter";

    private static final String FIELD_CROPOPERATION_FILTER = "cropOperationFilter";

    private static final String FIELD_SKYPCORRUPTGEOMETRIES_FILTER = "skipCorruptGeometries";

    private static final String FIELD_SORT_BY_GEOMETRY_TYPE = "sortByGeometryType";

    private static final String FIELD_LOGS_ERRORS = "logErrors";

    private static final String FIELD_IGNORE_Z = "ignoreZ";

    private static final String FIELD_GROUPBY = "groupby";

//    private static final String FIELD_APPLYCONVEXHULL = "applyConvexHull";

    private static final String FIELD_USE_Z_AS_ELEVATION = "useZAsElevation";

    private static final String FIELD_ELEVATION_FACTOR = "elevationFactor";

    private static final String FIELD_ROUND_ELEVATION = "roundElevation";

    public static final String FIELD_LINK_FILTER_INDEX = "LinkFilterIndex";

    public static final String FIELD_LINK_FILTER_TYPE = "LinkFilterType";

    public static final String FIELD_LINK_FILTER_ENTITY = "LinkFilterEntity";

    public static final String FIELD_LINK_FILTER_MS = "LinkFilterMS";

    public static final String FIELD_LINK_FILTER_DATA = "LinkFilterData";

    public static final String FIELD_GROUP_GEOMETRIES_OPERATION = "GroupGeometriesOperation";

    public static final String FIELD_FORZE2D = "force2D";

    private DelegatedDynObject parameters;

    public DGNOpenStoreParameters() {

        this(PARAMETERS_DEFINITION_NAME);

    }

    protected DGNOpenStoreParameters(String parametersDefinitionName) {

        this(parametersDefinitionName, DGNStoreProvider.NAME);

    }

    public DGNOpenStoreParameters(String parametersDefinitionName, String name) {

        super();

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

        this.setDynValue(DataStoreProviderServices.PROVIDER_PARAMTER_NAME, name);

    }

    public String getDataStoreName() {

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

    }

    public String getDescription() {

        return this.getDynClass().getDescription();

    }

    public void setCRS(IProjection srs) {

        setDynValue(FIELD_CRS, srs);

    }

    public void setCRS(String srs) {

        setDynValue(FIELD_CRS, srs);

    }

    public IProjection getCRS() {

        return (IProjection) getDynValue(FIELD_CRS);

    }

    public String getFileName() {

        return this.getFile().getPath();

    }

    public boolean isValid() {

        if (getCRS() == null) {

            return false;

        }

        if (getFile() == null) {

            return false;

        }

        return true;

    }

    public File getFile() {

        return (File) this.getDynValue(FIELD_FILE);

    }

    public File getXMLFile() {

        return (File) this.getDynValue(FIELD_XMLFILE);

    }

    public int getGeometryTypeFilter() {

        Integer x = (Integer) this.getDynValue(FIELD_GEOMTYPE_FILTER);

        if (x == null) {

            return Geometry.TYPES.GEOMETRY;

        }

        return x.intValue();

    }

    public int getLoadMode() {

        Integer x = (Integer) this.getDynValue(FIELD_LOAD_MODE);

        if (x == null) {

            return DGNStoreProvider.LOAD_MODE_PLAIN;

        }

        return x.intValue();

    }

    public int getGroupGeometriesOperation() {

        Integer x = (Integer) this.getDynValue(FIELD_GROUP_GEOMETRIES_OPERATION);

        if (x == null) {

            return DGNStoreProvider.GROUP_GEOMETRIES_NONE;

        }

        return x.intValue();

    }

    public double geElevationFactor() {

        Double x = (Double) this.getDynValue(FIELD_ELEVATION_FACTOR);

        if (x == null) {

            return 1;

        }

        return x.doubleValue();

    }

    public int getCropOperationFilter() {

        Integer x = (Integer) this.getDynValue(FIELD_CROPOPERATION_FILTER);

        if (x == null) {

            return DGNStoreProvider.CROP_OPERATION_NONE;

        }

        return x.intValue();

    }

    public Geometry getCropFilter() {

        Geometry x = (Geometry) this.getDynValue(FIELD_CROP_FILTER);

        return x;

    }

    public String getGroupBy() {

        return (String) this.getDynValue(FIELD_GROUPBY);

    }

    public String getLevelFilter() {

        return (String) this.getDynValue(FIELD_LEVEL_FILTER);

    }

    public String getGroupFilter() {

        return (String) this.getDynValue(FIELD_GROUP_FILTER);

    }

    public String getTextFilter() {

        return (String) this.getDynValue(FIELD_TEXT_FILTER);

    }

    public String getIDFilter() {

        return (String) this.getDynValue(FIELD_ID_FILTER);

    }

    public String getTypeFilter() {

        return (String) this.getDynValue(FIELD_TYPE_FILTER);

    }

    public String getSTypeFilter() {

        return (String) this.getDynValue(FIELD_STYPE_FILTER);

    }

    public String getColorFilter() {

        return (String) this.getDynValue(FIELD_COLOR_FILTER);

    }

    public String getStyleFilter() {

        return (String) this.getDynValue(FIELD_STYLE_FILTER);

    }

    public String getWeightFilter() {

        return (String) this.getDynValue(FIELD_WEIGHT_FILTER);

    }

    public boolean useReload() {

        Boolean x = (Boolean) this.getDynValue(FIELD_RELOAD);

        if (x == null) {

            return Boolean.FALSE;

        }

        return x.booleanValue();

    }

//    public boolean getApplyConvexHull() {

//        Boolean x = (Boolean) this.getDynValue(FIELD_APPLYCONVEXHULL);

//        if (x == null) {

//            return Boolean.FALSE;

//        }

//        return x.booleanValue();

//    }

    public boolean getApplyRoundToElevation() {

        Boolean x = (Boolean) this.getDynValue(FIELD_ROUND_ELEVATION);

        if (x == null) {

            return Boolean.FALSE;

        }

        return x.booleanValue();

    }

     public String getLinkFilterData() {

        return StringUtils.trimToNull((String) this.getDynValue(FIELD_LINK_FILTER_DATA));

    }

     public Pattern getLinkFilterDataAsPattern() {

        String s = getLinkFilterData();

        if( s == null ) {

            return null;

        }

        return Pattern.compile(s);

    }

    public Integer getLinkFilterIndex() {

        return (Integer) this.getDynValue(FIELD_LINK_FILTER_INDEX);

    }

    public Integer getLinkFilterType() {

        return (Integer) this.getDynValue(FIELD_LINK_FILTER_TYPE);

    }

    public Integer getLinkFilterEntity() {

        return (Integer) this.getDynValue(FIELD_LINK_FILTER_ENTITY);

    }

    public Integer getLinkFilterMS() {

        return (Integer) this.getDynValue(FIELD_LINK_FILTER_MS);

    }

    public boolean ignoreZs() {

        Boolean x = (Boolean) this.getDynValue(FIELD_IGNORE_Z);

        if (x == null) {

            return Boolean.FALSE;

        }

        return x.booleanValue();

    }

    public boolean logErrors() {

        Boolean x = (Boolean) this.getDynValue(FIELD_LOGS_ERRORS);

        if (x == null) {

            return Boolean.FALSE;

        }

        return x.booleanValue();

    }

    public boolean skipCorruptGeometries() {

        Boolean x = (Boolean) this.getDynValue(FIELD_SKYPCORRUPTGEOMETRIES_FILTER);

        if (x == null) {

            return Boolean.FALSE;

        }

        return x.booleanValue();

    }

    boolean useZAsElevation() {

        Boolean x = (Boolean) this.getDynValue(FIELD_USE_Z_AS_ELEVATION);

        if (x == null) {

            return Boolean.FALSE;

        }

        return x.booleanValue();

    }

    boolean force2D() {

        Boolean x = (Boolean) this.getDynValue(FIELD_FORZE2D);

        if (x == null) {

            return Boolean.FALSE;

        }

        return x.booleanValue();

    }

    public boolean sortByGeometryType() {

        Boolean x = (Boolean) this.getDynValue(FIELD_SORT_BY_GEOMETRY_TYPE);

        if (x == null) {

            return Boolean.TRUE;

        }

        return x.booleanValue();

    }

    public void setFile(File file) {

        this.setDynValue(FIELD_FILE, file);

    }

    public void setFile(String file) {

        this.setDynValue(FIELD_FILE, file);

    }

    public EditableFeatureType getDefaultFeatureType() {

        return null; //TODO ????

    }

    public void setDefaultFeatureType(FeatureType defaultFeatureType) {

        throw new UnsupportedOperationException();

    }

    protected DelegatedDynObject getDelegatedDynObject() {

        return parameters;

    }

}

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

import java.util.regex.Pattern;

import org.apache.commons.lang3.StringUtils;

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

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

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

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

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

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

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

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

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

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

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

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

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.GeometryLocator;

import org.gvsig.fmap.geom.GeometryManager;

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

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

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

public class PostProcessFilterOperation {

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

    private Pattern levelFilter = null;

    private Pattern colorFilter = null;

    private Pattern styleFilter = null;

    private Pattern weighFilter = null;

    private Pattern typeFilter = null;

    private Pattern stypeFilter = null;

    private Pattern idFilter = null;

    private Pattern groupFilter = null;

    private Pattern textFilter = null;

    private Point pointForCheckGeometries = null;

    private boolean hasfilter = false;

    private boolean skipCurruptGeometries = true;

    private int geometryTypeFilter = Geometry.TYPES.GEOMETRY;

    private int counter_exceptions = 0;

    private int cropOperationFilter;

    private Geometry cropFilter = null;

    private int ID_FIELD_LEVEL = -1;

    private int ID_FIELD_COLOR = -1;

    private int ID_FIELD_STYLE = -1;

    private int ID_FIELD_WEIGHT = -1;

    private int ID_FIELD_TYPE = -1;

    private int ID_FIELD_STYPE = -1;

    private int ID_FIELD_GROUP = -1;

    private int ID_FIELD_ID = -1;

    private int ID_FIELD_TEXT = -1;

    PostProcessFilterOperation(DGNOpenStoreParameters parameters, FeatureType featureType) {

        GeometryManager geomManager = GeometryLocator.getGeometryManager();

        geometryTypeFilter = parameters.getGeometryTypeFilter();

        skipCurruptGeometries = parameters.skipCorruptGeometries();

        if (!StringUtils.isBlank(parameters.getLevelFilter())) {

            this.levelFilter = Pattern.compile(parameters.getLevelFilter());

            this.ID_FIELD_LEVEL = featureType.getIndex(DGNStoreProvider.NAME_FIELD_LEVEL);

            this.hasfilter = true;

        }

        if (!StringUtils.isBlank(parameters.getColorFilter())) {

            colorFilter = Pattern.compile(parameters.getColorFilter());

            this.ID_FIELD_COLOR = featureType.getIndex(DGNStoreProvider.NAME_FIELD_COLOR);

            this.hasfilter = true;

        }

        if (!StringUtils.isBlank(parameters.getStyleFilter())) {

            styleFilter = Pattern.compile(parameters.getStyleFilter());

            this.ID_FIELD_STYLE = featureType.getIndex(DGNStoreProvider.NAME_FIELD_STYLE);

            this.hasfilter = true;

        }

        if (!StringUtils.isBlank(parameters.getTypeFilter())) {

            this.typeFilter = Pattern.compile(parameters.getTypeFilter());

            this.ID_FIELD_TYPE = featureType.getIndex(DGNStoreProvider.NAME_FIELD_TYPE);

            this.hasfilter = true;

        }

        if (!StringUtils.isBlank(parameters.getSTypeFilter())) {

            this.stypeFilter = Pattern.compile(parameters.getSTypeFilter());

            this.ID_FIELD_STYPE = featureType.getIndex(DGNStoreProvider.NAME_FIELD_STYPE);

            this.hasfilter = true;

        }

        if (!StringUtils.isBlank(parameters.getWeightFilter())) {

            weighFilter = Pattern.compile(parameters.getWeightFilter());

            this.ID_FIELD_WEIGHT = featureType.getIndex(DGNStoreProvider.NAME_FIELD_WEIGHT);

            this.hasfilter = true;

        }

        if (!StringUtils.isBlank(parameters.getGroupFilter())) {

            groupFilter = Pattern.compile(parameters.getGroupFilter());

            this.ID_FIELD_GROUP = featureType.getIndex(DGNStoreProvider.NAME_FIELD_GROUP);

            this.hasfilter = true;

        }

        if (!StringUtils.isBlank(parameters.getIDFilter())) {

            idFilter = Pattern.compile(parameters.getIDFilter());

            this.ID_FIELD_ID = featureType.getIndex(DGNStoreProvider.NAME_FIELD_ID);

            this.hasfilter = true;

        }

        if (!StringUtils.isBlank(parameters.getTextFilter())) {

            textFilter = Pattern.compile(parameters.getTextFilter());

            this.ID_FIELD_TEXT = featureType.getIndex(DGNStoreProvider.NAME_FIELD_TEXT);

            this.hasfilter = true;

        }

        if (this.geometryTypeFilter != Geometry.TYPES.GEOMETRY) {

            this.hasfilter = true;

        }

        this.cropFilter = parameters.getCropFilter();

        if (this.cropFilter != null) {

            this.hasfilter = true;

        }

        this.cropOperationFilter = parameters.getCropOperationFilter();

        if (this.cropOperationFilter == CROP_OPERATION_NONE) {

            this.cropFilter = null;

        }

        this.pointForCheckGeometries = null;

        if (skipCurruptGeometries) {

            try {

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

                this.pointForCheckGeometries = geomManager.createPoint(1, 1, geomSubtype);

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

                    this.pointForCheckGeometries.setCoordinateAt(Geometry.DIMENSIONS.Z, 1);

                }

            } catch (Exception ex) {

                this.pointForCheckGeometries = null;

            }

        }

    }

    public boolean hasFilter() {

        return this.hasfilter;

    }

    private boolean match(Pattern exp, Object value) {

        if (value == null) {

            return false;

        }

        return exp.matcher(value.toString()).matches();

    }

    public boolean accept(FeatureProvider data) {

        if (!this.hasfilter) {

            return true;

        }

        Geometry geometry = data.getDefaultGeometry();

        if (this.pointForCheckGeometries != null) {

            if (geometry != null) {

                try {

                    this.pointForCheckGeometries.intersects(geometry);

                } catch (Exception ex) {

                    // Skip geometries with problems

                    data.setDefaultGeometry(null);

                    geometry = null;

                }

            }

        }

        try {

            if (levelFilter!=null && !match(levelFilter, data.get(ID_FIELD_LEVEL))) {

                return false;

            }

            if (colorFilter!=null && !match(colorFilter, data.get(ID_FIELD_COLOR))) {

                return false;

            }

            if (styleFilter!=null && !match(styleFilter, data.get(ID_FIELD_STYLE))) {

                return false;

            }

            if (weighFilter!=null && !match(weighFilter, data.get(ID_FIELD_WEIGHT))) {

                return false;

            }

            if (typeFilter!=null && !match(typeFilter, data.get(ID_FIELD_TYPE))) {

                return false;

            }

            if (stypeFilter!=null && !match(stypeFilter, data.get(ID_FIELD_STYPE))) {

                return false;

            }

            if (groupFilter!=null && !match(groupFilter, data.get(ID_FIELD_GROUP))) {

                return false;

            }

            if (idFilter!=null && !match(idFilter, data.get(ID_FIELD_ID))) {

                return false;

            }

            if (textFilter!=null && !match(textFilter, data.get(ID_FIELD_TEXT))) {

                return false;

            }

            if (geometry != null) {

                if (geometryTypeFilter != Geometry.TYPES.GEOMETRY) {

                    GeometryType geomtype = geometry.getGeometryType();

                    switch (geometryTypeFilter) {

                        case Geometry.TYPES.POINT:

                            if (!geomtype.isTypeOf(Geometry.TYPES.POINT)

                                    && !geomtype.isTypeOf(Geometry.TYPES.MULTIPOINT)) {

                                return false;

                            }

                            break;

                        case Geometry.TYPES.CURVE:

                            if (!geomtype.isTypeOf(Geometry.TYPES.CURVE)

                                    && !geomtype.isTypeOf(Geometry.TYPES.MULTICURVE)) {

                                return false;

                            }

                            break;

                        case Geometry.TYPES.SURFACE:

                            if (!geomtype.isTypeOf(Geometry.TYPES.SURFACE)

                                    && !geomtype.isTypeOf(Geometry.TYPES.MULTISURFACE)) {

                                return false;

                            }

                            break;

                        default:

                            break;

                    }

                }

                if (this.cropFilter != null) {

                    switch (this.cropOperationFilter) {

                        case CROP_OPERATION_CONTAINS: