Application: gvSIG desktop » gvSIG data provider for DWG

/* 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.dwg.fmap.dal.store.dwg;

import java.io.File;

import org.gvsig.fmap.dal.DataStoreParameters;

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

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

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

public class TestDWG extends BaseTestFeatureStore {

	protected boolean testDXFInitialized = false;

	public static File file_prueba = new File(TestDWG.class.getResource(

			"data/V2000.dwg").getFile());

	/*

	 * (non-Javadoc)

	 *

	 * @see

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

	 * ()

	 */

	public DataStoreParameters getDefaultDataStoreParameters()

			throws DataException {

		DWGStoreParameters dwgParameters = null;

		dwgParameters = (DWGStoreParameters) dataManager

				.createStoreParameters(DWGStoreProvider.NAME);

		dwgParameters.setFile(file_prueba);

		dwgParameters.setCRS("EPSG:23030");

		return dwgParameters;

	}

	/*

	 * (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 {

		DataStoreParameters params = getDefaultDataStoreParameters();

		FeatureStore store = (FeatureStore) dataManager.openStore(params

				.getDataStoreName(), params);

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

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

		store.dispose();

	}

}

/* 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):

* 2009 IVER T.I   {{Task}}

*/

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

import java.io.File;

public class TestDWG2004 extends TestDWG {

	public static File file_prueba = new File(TestDWG.class.getResource(

			"data/V2004.dwg").getFile());

}

/* 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.

 *

 */

package org.gvsig.dwg;

import org.gvsig.andami.IconThemeHelper;

import org.gvsig.andami.plugins.Extension;

import org.gvsig.dwg.fmap.dal.store.dwg.DWGStoreProvider;

import org.gvsig.fmap.mapcontext.MapContextLocator;

/**

 * Dummy DWG extension, as all the registration happens in the

 * {@link DWGLibrary}.

 *

 * @author gvSIG Team

 */

public class DWGRegisterExtension extends Extension {

	public void execute(String actionCommand) {

		// Nothing to do

	}

	public void initialize() {

		IconThemeHelper.registerIcon("layer", "layer-icon-dwg", this);

	}

	public void postInitialize() {

		MapContextLocator.getMapContextManager().registerIconLayer(DWGStoreProvider.NAME, "layer-icon-dwg");

	}

	public boolean isEnabled() {

		// Nothing to do

		return false;

	}

	public boolean isVisible() {

		// Nothing to do

		return false;

	}

}

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

<plugin-config>

	<libraries library-dir="lib">

	</libraries>

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

		<resourceBundle name="text"/>

	<extensions>

		<extension class-name="org.gvsig.dwg.DWGRegisterExtension"

			description="DWG Driver"

			active="true">

		</extension>

	</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.dwg.provider.legend</include>

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

        <include>org.gvsig:org.gvsig.dwg.lib</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.dwg.app.mainplugin</artifactId>

  <packaging>jar</packaging>

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

  <description>

DWG file format support (read-only)

Supported versions:

- v12

- v14

- v15

- v2004

  </description>

  <parent>

      <groupId>org.gvsig</groupId>

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

      <version>2.0.264</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.dwg.provider</artifactId>

        <scope>compile</scope>

    </dependency>

    <dependency>

        <groupId>org.gvsig</groupId>

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

        <scope>compile</scope>

    </dependency>

    <dependency>

        <groupId>org.gvsig</groupId>

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

        <scope>runtime</scope>

    </dependency>

    <!-- Tests -->

    <dependency>

      <groupId>org.gvsig</groupId>

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

      <type>test-jar</type>

      <scope>test</scope>

    </dependency>

    <dependency>

      <groupId>org.gvsig</groupId>

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

      <type>jar</type>

      <scope>test</scope>

    </dependency>

  </dependencies>

    <properties>

        <!-- Package info property values -->

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

        <gvsig.package.info.name>Formats: dwg file format support (read-only)</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-dwg/pool</gvsig.package.info.poolURL>

    </properties>

  <build>

    <plugins>

      <plugin>

        <!-- Skip compilation tests -->

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

        <artifactId>maven-compiler-plugin</artifactId>

        <executions>

          <execution>

            <id>default-testCompile</id>

            <phase>process-test-sources</phase>

            <goals>

              <goal>testCompile</goal>

            </goals>

            <configuration>

              <skip>true</skip>

            </configuration>

          </execution>

        </executions>

      </plugin>

      <plugin>

        <!-- Skip test execution -->

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

        <artifactId>maven-surefire-plugin</artifactId>

        <configuration>

          <skipTests>true</skipTests>

        </configuration>

      </plugin>

    </plugins>

  </build>

</project>

#Sun Feb 04 23:15:30 CET 2024

buildNumber=2333

<?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.dwg.app</artifactId>

  <packaging>pom</packaging>

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

  <parent>

      <groupId>org.gvsig</groupId>

      <artifactId>org.gvsig.dwg</artifactId>

      <version>2.0.264</version>

  </parent>

  <modules>

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

  </modules>

</project>

/*

 * Created on 01-feb-2007

 *

 * 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.

 *

 * For more information, contact:

 *

 *  Generalitat Valenciana

 *   Conselleria d'Infraestructures i Transport

 *   Av. Blasco Ib??ez, 50

 *   46010 VALENCIA

 *   SPAIN

 *

 *      +34 963862235

 *   gvsig@gva.es

 *      www.gvsig.gva.es

 *

 *    or

 *

 *   IVER T.I. S.A

 *   Salamanca 50

 *   46005 Valencia

 *   Spain

 *

 *   +34 963163400

 *   dac@iver.es

 */

/* CVS MESSAGES:

*

* $Id: CorruptedDwgEntityException.java 28969 2009-05-25 13:23:12Z jmvivo $

* $Log$

* Revision 1.1.2.2  2007-03-21 19:49:16  azabala

* implementation of dwg 12, 13, 14.

*

* Revision 1.1  2007/02/01 20:00:27  azabala

* *** empty log message ***

*

*

*/

package org.gvsig.dwg.lib;

public class CorruptedDwgEntityException extends Exception {

	public CorruptedDwgEntityException(String string) {

		super(string);

	}

}

/*

 * Created on 04-mar-2007

 *

 * 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.

 *

 * For more information, contact:

 *

 *  Generalitat Valenciana

 *   Conselleria d'Infraestructures i Transport

 *   Av. Blasco Ib??ez, 50

 *   46010 VALENCIA

 *   SPAIN

 *

 *      +34 963862235

 *   gvsig@gva.es

 *      www.gvsig.gva.es

 *

 *    or

 *

 *   IVER T.I. S.A

 *   Salamanca 50

 *   46005 Valencia

 *   Spain

 *

 *   +34 963163400

 *   dac@iver.es

 */

/* CVS MESSAGES:

*

* $Id: IDwgVertex.java 28969 2009-05-25 13:23:12Z jmvivo $

* $Log$

* Revision 1.2.2.1  2007-03-21 19:49:16  azabala

* implementation of dwg 12, 13, 14.

*

* Revision 1.2  2007/03/20 19:55:27  azabala

* source code cleaning

*

* Revision 1.1  2007/03/06 19:39:38  azabala

* Changes to adapt dwg 12 to general architecture

*

*

*/

package org.gvsig.dwg.lib;

/**

 * Base interface for all DWG vertices. 

 * 

 * @author azabala

 * 

 * */

public interface IDwgVertex {

	public double[] getPoint();

	public void setPoint(double[] point);

}

/* jdwglib. Java Library for reading Dwg files.

 * 

 * Author: Jose Morell Rama (jose.morell@gmail.com).

 * Port from the Pythoncad Dwg library by Art Haas.

 *

 * Copyright (C) 2005 Jose Morell, IVER TI S.A. 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.

 *

 * For more information, contact:

 *

 * Jose Morell (jose.morell@gmail.com)

 * 

 * or

 *

 * IVER TI S.A.

 *  C/Salamanca, 50

 *  46005 Valencia

 *  Spain

 *  +34 963163400

 *  dac@iver.es

 */

package org.gvsig.dwg.lib;

/**

 * The DwgHeader class implements the Header of a DWG file

 * 

 * @author jmorell

 */

public class DwgHeader {

}

/*

 *

 * Este codigo se distribuye bajo licencia GPL

 * de GNU. Para obtener una c?pia integra de esta

 * licencia acude a www.gnu.org.

 * 

 * Este software se distribuye "como es". AGIL

 * solo  pretende desarrollar herramientas para

 * la promoci?n del GIS Libre.

 * AGIL no se responsabiliza de las perdidas econ?micas o de 

 * informaci?n derivadas del uso de este software.

 */

package org.gvsig.dwg.lib.util;

/**

 *  3dim double point. A point is transformed different than a vector.

 *  The class is now declared final to allow a more aggresive optimization.

 *

 *  @see       dxfviewer.math.Vector3D;

 *

 *  @version   1.10,?01/13/99

 */

public final class Point3D {

  public double   x, y, z;     // coordinates, allowing direct access

  /**

   *

   */

  public Point3D() {

  }

  /**

   *  Copy constructor.

   *  @param  p    point to copy

   */

  public Point3D(Point3D p) {

	x = p.x;

	y = p.y;

	z = p.z;

  }

  /**

   *  @param   xx    x coord

   *  @param   yy    y coord

   *  @param   zz    z coord

   */

  public Point3D(double xx, double yy, double zz) {

	x = xx;

	y = yy;

	z = zz;

  }

  /**

   *  Scale.

   *  @param   f     scaling factor

   */

  public void scale(double f) {

	if (f != 1f) {

	  x *= f;

	  y *= f;

	  z *= f;

	}

  }

  /**

   *  Add a vector.

   *  @param  v      vector to add

   */

  public void add(Vector3D v) {

	x += v.x;

	y += v.y;

	z += v.z;

  }

  /**

   *  Get sum with vector.

   *  @param  v     vector to add

   *  @return this+v

   */

  public Point3D plus(Vector3D v) {

	Point3D ret = new Point3D(this);

	ret.add(v);

	return ret;

  }

  /**

   *  Substract a vector.

   *  @param  v     vector to substract

   */

  public void sub(Vector3D v) {

	x -= v.x;

	y -= v.y;

	z -= v.z;

  }

  /**

   *  Get difference with vector.

   *  @param  v     vector to substract

   *  @return this-v

   */

  public Point3D minus(Vector3D v) {

	Point3D ret = new Point3D(this);

	ret.sub(v);

	return ret;

  }

  /**

   *  Get difference with point.

   *  @param  p     point to substract

   *  @return this-p

   */

  public Vector3D minus(Point3D p) {

	Vector3D ret = new Vector3D(this);

	ret.sub(new Vector3D(p));

	return ret;

  }

  /**

   *  Output.

   *  @return  output string

   */

  public String toString() {

	return new String(new StringBuffer().append("[").append(x).append(",").append(y).append(",").append(z).append("]"));

  }

}

/*

 * Created on 18-ene-2007 by azabala

 *

 */

package org.gvsig.dwg.lib.util;

import java.awt.geom.Point2D;

import java.util.Iterator;

import java.util.List;

import org.gvsig.dwg.lib.IDwgVertex;

import org.gvsig.fmap.geom.Geometry;

import org.gvsig.fmap.geom.GeometryLocator;

import org.gvsig.fmap.geom.GeometryManager;

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

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

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

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

/**

 * @author alzabord

 *

 */

public class FMapUtil {

    private static final GeometryManager gManager = GeometryLocator

            .getGeometryManager();

    public static Line ptsToLine(List<double[]> pts, int subType)

            throws CreateGeometryException {

        if (pts.size() < 2) {

            throw new IllegalArgumentException();

        }

        try {

            boolean is3D = subType == Geometry.SUBTYPES.GEOM3D || subType == Geometry.SUBTYPES.GEOM3DM;

            Line line = gManager.createLine(subType);

            for (double[] p : pts) {

                if( is3D ) {

                    if( p.length<3 ) {

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

                    } else {

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

                    }

                } else {

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

                }

            }

            return line;

        } catch(RuntimeException ex) {

            throw ex;

        }

    }

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

            throws CreateGeometryException {

        if (pts.size() < 3) {

            throw new IllegalArgumentException();

        }

        boolean is3D = subType == Geometry.SUBTYPES.GEOM3D || subType == Geometry.SUBTYPES.GEOM3DM;

        Polygon polygon = gManager.createPolygon(subType);

        for (double[] p : pts) {

            if( is3D ) {

                polygon.addVertex(p[0],p[1],p[2]);            

            } else {

                polygon.addVertex(p[0],p[1]);            

            }

        }

        return polygon;

    }

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

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

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

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

        }

        return result;

    }

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

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

        return result;

    }

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

        double[] point = dwgvertex.getPoint();

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

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

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

        }

        return result;

    }

    /**

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

     * diferencia entre angle1 y angle2 en sentido antihorario

     *

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

     * vuelta a la circunferencia

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

     * vuelta a la circunferencia

     *

     * @return distancia entre los �ngulos

     */

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

        if (angle1 < angle2) {

            return angle2 - angle1;

        } else {

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

        }

    }

}

/* jdwglib. Java Library for reading Dwg files.

 * 

 * Author: Jose Morell Rama (jose.morell@gmail.com).

 * Port from the Pythoncad Dwg library by Art Haas.

 *

 * Copyright (C) 2005 Jose Morell, IVER TI S.A. 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.

 *

 * For more information, contact:

 *

 * Jose Morell (jose.morell@gmail.com)

 * 

 * or

 *

 * IVER TI S.A.

 *  C/Salamanca, 50

 *  46005 Valencia

 *  Spain

 *  +34 963163400

 *  dac@iver.es

 */

package org.gvsig.dwg.lib.util;

import java.awt.geom.Point2D;

import java.util.Vector;

/**

 * This class calculates an arc given by a start and end points and a bulge

 * 

 * @author jmorell

 */

public class ArcFromBulgeCalculator {

	private double[] coord1, coord2;

	private double[] center;

	private double radio, empieza, acaba;

	private double bulge;

	private double d, dd, aci;

	private double[] coordAux;

	/**

	 * This method calculates an arc given by a start and end points and a bulge

	 * 

	 * @param p1 Start point of the arc given by a Point2D

	 * @param p2 End point of the arc given by a Point2D

	 * @param bulge Bulge of the arc given by a double value 

	 */

	public ArcFromBulgeCalculator(double[] p1, double[] p2, double bulge) {

		this.bulge = bulge;

		if (bulge < 0.0) {

			coord1 = p2;

			coord2 = p1;

		} else {

			coord1 = p1;

			coord2 = p2;

		}

		calParams();

	}

	private void calParams() {

		d = Math.sqrt((coord2[0]-coord1[0])*(coord2[0]-coord1[0]) + 

				(coord2[1]-coord1[1])*(coord2[1]-coord1[1]));

		coordAux = new double[]{(coord1[0]+coord2[0])/2.0, (coord1[1]+coord2[1])/2.0};

		double b = Math.abs(bulge);

		double beta = Math.atan(b);

		double alfa = beta*4.0;

		double landa = alfa/2.0;

		dd = (d/2.0)/(Math.tan(landa));

		radio = (d/2.0)/(Math.sin(landa));		

		aci = Math.atan((coord2[0]-coord1[0])/(coord2[1]-coord1[1]));

		double aciDegree = aci*180.0/Math.PI;

		if (coord2[1] > coord1[1]) {

			aci += Math.PI;

			aciDegree = aci*180.0/Math.PI;

		}

		center = new double[]{coordAux[0] + dd*Math.sin(aci+(Math.PI/2.0)), coordAux[1] + dd*Math.cos(aci+(Math.PI/2.0))};

		calEA(alfa);

	}

	private void calEA(double alfa){

		empieza = Math.atan2(coord1[1]-center[1], coord1[0]-center[0]);

		acaba = (empieza + alfa);

		empieza = empieza*180.0/Math.PI;

		acaba = acaba*180.0/Math.PI;

	}

	/**

	 * This method calculates an arc in a Gis geometry model. This arc is represented in

	 * this model by a Vector of Point2D. The distance between points in the arc is given

	 * as an argument

	 * 

	 * @param inc Distance between points in the arc

	 * @return Vector Vector with the set of Point2D that represents the arc

	 */

	public Vector getPoints(double inc) {

		Vector arc = new Vector();

		double angulo;

		int iempieza = (int) empieza + 1;

		int iacaba = (int) acaba;

		if (empieza <= acaba) {

			addNode(arc, empieza);

			for (angulo = iempieza; angulo <= iacaba; angulo += inc) {

				addNode(arc, angulo);

			}

			addNode(arc, acaba);

		} else {

			addNode(arc, empieza);

			for (angulo = iempieza ; angulo <= 360; angulo += inc) {

				addNode(arc, angulo);

			}

			for (angulo = 1; angulo <= iacaba; angulo += inc) {

				addNode(arc, angulo);

			}

			addNode(arc, angulo);

		}

		Point2D aux = (Point2D)arc.get(arc.size()-1);

		double aux1 = Math.abs(aux.getX()-coord2[0]);

		double aux2 = Math.abs(aux.getY()-coord2[1]);

		return arc;

	}

	/**

	 * Method that allows to obtain a set of points located in the central zone of 

	 * this arc object

	 */

	public Vector getCentralPoint() {

		Vector arc = new Vector();

		if (empieza <= acaba) {

			addNode(arc, (empieza+acaba)/2.0);

		} else {

			addNode(arc, empieza);

			double alfa = 360-empieza;

			double beta = acaba;

			double an = alfa + beta;

			double mid = an/2.0;

			if (mid<=alfa) {

				addNode(arc, empieza+mid);

			} else {

				addNode(arc, mid-alfa);

			}

		}

		return arc;

	}

	private void addNode(Vector arc, double angulo) {

		double yy = center[1] + radio * Math.sin(angulo*Math.PI/180.0);

		double xx = center[0] + radio * Math.cos(angulo*Math.PI/180.0);		

		arc.add(new Point2D.Double(xx,yy));

	}

}

/* jdwglib. Java Library for reading Dwg files.

 * 

 * Author: Jose Morell Rama (jose.morell@gmail.com).

 * Port from the Pythoncad Dwg library by Art Haas.

 *

 * Copyright (C) 2005 Jose Morell, IVER TI S.A. 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.

 *

 * For more information, contact:

 *

 * Jose Morell (jose.morell@gmail.com)

 * 

 * or

 *

 * IVER TI S.A.

 *  C/Salamanca, 50

 *  46005 Valencia

 *  Spain

 *  +34 963163400

 *  dac@iver.es

 */

package org.gvsig.dwg.lib.util;

import java.awt.geom.Point2D;

import java.util.ArrayList;

import java.util.List;

import java.util.Vector;

/**

 * This class allows to obtain arcs and circles given by the most usual parameters, in a

 * Gis geometry model. In this model, an arc or a circle is given by a set of points that

 * defines it shape

 * 

 * @author jmorell

 */

public class GisModelCurveCalculator {

    /**

     * This method calculates an array of Point2D that represents a circle. The distance

     * between it points is 1 angular unit 

     * 

     * @param c Point2D that represents the center of the circle

     * @param r double value that represents the radius of the circle

     * @return Point2D[] An array of Point2D that represents the shape of the circle

     */

	public static List calculateGisModelCircle(Point2D c, double r) {

		List pts = new ArrayList();

		int angulo = 0;

		for (angulo=0; angulo<360; angulo++) {

			double[] pt = new double[]{c.getX(), c.getY()};

			pt[0] = pt[0] + r * Math.sin(angulo*Math.PI/(double)180.0);

			pt[1] = pt[1] + r * Math.cos(angulo*Math.PI/(double)180.0);

			pts.add(pt);

		}

		return pts;

	}

    /**

     * This method calculates an array of Point2D that represents a ellipse. The distance

     * between it points is 1 angular unit 

     * 

     * @param center Point2D that represents the center of the ellipse

     * @param majorAxisVector Point2D that represents the vector for the major axis

     * @param axisRatio double value that represents the axis ratio

	 * @param initAngle double value that represents the start angle of the ellipse arc

	 * @param endAngle double value that represents the end angle of the ellipse arc

     * @return Point2D[] An array of Point2D that represents the shape of the ellipse

     */

	public static List calculateGisModelEllipse(Point2D center, Point2D majorAxisVector, double axisRatio, double initAngle, double endAngle) {

		Point2D majorPoint = new Point2D.Double(center.getX()+majorAxisVector.getX(), center.getY()+majorAxisVector.getY());

		double orientation  = Math.atan(majorAxisVector.getY()/majorAxisVector.getX());

	    double semiMajorAxisLength = center.distance(majorPoint);

		double semiMinorAxisLength = semiMajorAxisLength*axisRatio;

	    double eccentricity = Math.sqrt(1-((Math.pow(semiMinorAxisLength, 2))/(Math.pow(semiMajorAxisLength, 2))));

		int isa = (int)initAngle;

		int iea = (int)endAngle;

		double angulo;

		List pts = new ArrayList();

		if (initAngle <= endAngle) {

			angulo = initAngle;

			double r = semiMinorAxisLength/Math.sqrt(1-((Math.pow(eccentricity, 2))*(Math.pow(Math.cos(angulo*Math.PI/(double)180.0), 2))));

		    double x = r*Math.cos(angulo*Math.PI/(double)180.0);

		    double y = r*Math.sin(angulo*Math.PI/(double)180.0);

		    double xrot = x*Math.cos(orientation) - y*Math.sin(orientation);

		    double yrot = x*Math.sin(orientation) + y*Math.cos(orientation);

			double[] pt = new double[]{center.getX() + xrot, center.getY() + yrot };

			pts.add(pt);

			for (int i=1; i<=(iea-isa)+1; i++) {

				angulo = (double)(isa+i);

				r = semiMinorAxisLength/Math.sqrt(1-((Math.pow(eccentricity, 2))*(Math.pow(Math.cos(angulo*Math.PI/(double)180.0), 2))));

			    x = r*Math.cos(angulo*Math.PI/(double)180.0);

			    y = r*Math.sin(angulo*Math.PI/(double)180.0);

			    xrot = x*Math.cos(orientation) - y*Math.sin(orientation);

			    yrot = x*Math.sin(orientation) + y*Math.cos(orientation);

			    pt = new double[]{center.getX() + xrot, center.getY() + yrot};

			    pts.add(pt);

			}

			angulo = endAngle;

			r = semiMinorAxisLength/Math.sqrt(1-((Math.pow(eccentricity, 2))*(Math.pow(Math.cos(angulo*Math.PI/(double)180.0), 2))));

		    x = r*Math.cos(angulo*Math.PI/(double)180.0);

		    y = r*Math.sin(angulo*Math.PI/(double)180.0);

		    xrot = x*Math.cos(orientation) - y*Math.sin(orientation);

		    yrot = x*Math.sin(orientation) + y*Math.cos(orientation);

		    pt = new double[]{center.getX() + xrot, center.getY() + yrot};

		    pts.add(pt);

		} else {

			angulo = initAngle;

			double r = semiMinorAxisLength/Math.sqrt(1-((Math.pow(eccentricity, 2))*(Math.pow(Math.cos(angulo*Math.PI/(double)180.0), 2))));

		    double x = r*Math.cos(angulo*Math.PI/(double)180.0);

		    double y = r*Math.sin(angulo*Math.PI/(double)180.0);

		    double xrot = x*Math.cos(orientation) - y*Math.sin(orientation);

		    double yrot = x*Math.sin(orientation) + y*Math.cos(orientation);

			double[] pt = new double[]{center.getX() + r*Math.cos(angulo*Math.PI/(double)180.0), center.getY() + r*Math.sin(angulo*Math.PI/(double)180.0)};

		    pts.add(pt);

		    for (int i=1; i<=(360-isa); i++) {

				angulo = (double)(isa+i);

				r = semiMinorAxisLength/Math.sqrt(1-((Math.pow(eccentricity, 2))*(Math.pow(Math.cos(angulo*Math.PI/(double)180.0), 2))));

			    x = r*Math.cos(angulo*Math.PI/(double)180.0);

			    y = r*Math.sin(angulo*Math.PI/(double)180.0);

			    xrot = x*Math.cos(orientation) - y*Math.sin(orientation);

			    yrot = x*Math.sin(orientation) + y*Math.cos(orientation);

			    pt = new double[]{center.getX() + xrot, center.getY() + yrot};

			    pts.add(pt);

			}

			for (int i=(360-isa)+1; i<=(360-isa)+iea; i++) {

				angulo = (double)(i-(360-isa));

				r = semiMinorAxisLength/Math.sqrt(1-((Math.pow(eccentricity, 2))*(Math.pow(Math.cos(angulo*Math.PI/(double)180.0), 2))));

			    x = r*Math.cos(angulo*Math.PI/(double)180.0);

			    y = r*Math.sin(angulo*Math.PI/(double)180.0);

			    xrot = x*Math.cos(orientation) - y*Math.sin(orientation);

			    yrot = x*Math.sin(orientation) + y*Math.cos(orientation);

			    pt = new double[]{center.getX() + xrot, center.getY() + yrot};

			    pts.add(pt);

			}

			angulo = endAngle;

			r = semiMinorAxisLength/Math.sqrt(1-((Math.pow(eccentricity, 2))*(Math.pow(Math.cos(angulo*Math.PI/(double)180.0), 2))));

		    x = r*Math.cos(angulo*Math.PI/(double)180.0);

		    y = r*Math.sin(angulo*Math.PI/(double)180.0);

		    xrot = x*Math.cos(orientation) - y*Math.sin(orientation);

		    yrot = x*Math.sin(orientation) + y*Math.cos(orientation);

		    pt = new double[]{center.getX() + xrot, center.getY() + yrot};

		    pts.add(pt);

		}

		return pts;

	}

	/**

     * This method calculates an array of Point2D that represents an arc. The distance

     * between it points is 1 angular unit 

	 * 

     * @param c Point2D that represents the center of the arc

     * @param r double value that represents the radius of the arc

	 * @param sa double value that represents the start angle of the arc

	 * @param ea double value that represents the end angle of the arc

     * @return Point2D[] An array of Point2D that represents the shape of the arc

	 */

	public static List calculateGisModelArc(double[] center, double r, double sa, double ea) {

		int isa = (int)sa;

		int iea = (int)ea;

		double angulo;

		List pts = new ArrayList();

		if (sa <= ea) {

			angulo = sa;

			pts.add(new double[]{center[0] + r * Math.cos(angulo*Math.PI/(double)180.0), 

					center[1] + r * Math.sin(angulo*Math.PI/(double)180.0)});

			for (int i=1; i <= (iea-isa)+1; i++) {

				angulo = (double)(isa+i);

				double x = center[0] + r * Math.cos(angulo*Math.PI/(double)180.0);

				double y = center[1] + r * Math.sin(angulo*Math.PI/(double)180.0);

				pts.add(new double[]{x, y});

			}

			angulo = ea;

			double x = center[0] + r * Math.cos(angulo*Math.PI/(double)180.0);

			double y = center[1] + r * Math.sin(angulo*Math.PI/(double)180.0);

			pts.add(new double[]{x, y});

		} else {

			angulo = sa;

			double x = center[0] + r * Math.cos(angulo*Math.PI/(double)180.0);

			double y = center[1] + r * Math.sin(angulo*Math.PI/(double)180.0);

			pts.add(new double[]{x, y});

			for (int i=1; i <= (360-isa); i++) {

				angulo = (double)(isa+i);

				x = center[0] + r * Math.cos(angulo*Math.PI/(double)180.0);

				y = center[1] + r * Math.sin(angulo*Math.PI/(double)180.0); 

				pts.add(new double[]{x, y});

			}

			for (int i=( 360-isa)+1; i <= (360-isa)+iea; i++) {

				angulo = (double)(i-(360-isa));

				x = center[0] + r * Math.cos(angulo*Math.PI/(double)180.0);

				y = center[1] + r * Math.sin(angulo*Math.PI/(double)180.0);

				pts.add(new double[]{x, y});

			}

			angulo = ea;

			x = center[0] + r * Math.cos(angulo*Math.PI/(double)180.0);

			y = center[1] + r * Math.sin(angulo*Math.PI/(double)180.0);

			pts.add(new double[]{x, y});

		}

		return pts;

	}

	/**

	 * This method applies an array of bulges to an array of Point2D that defines a

	 * polyline. The result is a polyline with the input points with the addition of the

	 * points that define the new arcs added to the polyline

	 * 

	 * @param newPts Base points of the polyline

	 * @param bulges Array of bulge parameters

	 * @return Polyline with a new set of arcs added and defined by the bulge parameters

	 */

	public static List calculateGisModelBulge(List newPts, double[] bulges) {

		Vector ptspol = new Vector();

		double[] init = null;

		double[] end = null;

		for (int j=0; j<newPts.size(); j++) {

			init = (double[]) newPts.get(j);

			if (j != newPts.size()-1) 

				end = (double[]) newPts.get(j+1);

			if (bulges[j]==0 || j== newPts.size()-1 || 

				(init[0] == end[0] && init[1] == end[1])) {

				ptspol.add(init);

			} else {

				ArcFromBulgeCalculator arcCalculator = new ArcFromBulgeCalculator(init, end, bulges[j]);

				Vector arc = arcCalculator.getPoints(1);

				if (bulges[j]<0) {

					for (int k=arc.size()-1; k>=0; k--) {

						ptspol.add(arc.get(k));

					}

					ptspol.remove(ptspol.size()-1);

				} else {

					for (int k=0;k<arc.size();k++) {

						ptspol.add(arc.get(k));

					}

					ptspol.remove(ptspol.size()-1);

				}

			}

		}

		List points = new ArrayList();

		for (int j=0;j<ptspol.size();j++) {

			points.add(ptspol.get(j));

		}

		return points;

	}

}

package org.gvsig.dwg.lib.util;

import java.util.BitSet;

/**

 * Number in hexadecimal format are used throughout Freenet.

 * 

 * <p>Unless otherwise stated, the conventions follow the rules outlined in the 

 * Java Language Specification.</p>

 * 

 * @author syoung

 */

public class HexUtil {

	private HexUtil() {		

	}	

	/**

	 * Converts a byte array into a string of upper case hex chars.

	 * 

	 * @param bs

	 *            A byte array

	 * @param off

	 *            The index of the first byte to read

	 * @param length

	 *            The number of bytes to read.

	 * @return the string of hex chars.

	 */

	public static final String bytesToHex(byte[] bs, int off, int length) {

		StringBuffer sb = new StringBuffer(length * 2);

		bytesToHexAppend(bs, off, length, sb);

		return sb.toString();

	}

	public static final void bytesToHexAppend(

		byte[] bs,

		int off,

		int length,

		StringBuffer sb) {

		sb.ensureCapacity(sb.length() + length * 2);

		for (int i = off; i < (off + length) && i < bs.length; i++) {

			sb.append(Character.forDigit((bs[i] >>> 4) & 0xf, 16));

			sb.append(Character.forDigit(bs[i] & 0xf, 16));

		}

	}

	public static final String bytesToHex(byte[] bs) {

		return bytesToHex(bs, 0, bs.length);

	}

	public static final byte[] hexToBytes(String s) {

		return hexToBytes(s, 0);

	}

	public static final byte[] hexToBytes(String s, int off) {

		byte[] bs = new byte[off + (1 + s.length()) / 2];

		hexToBytes(s, bs, off);

		return bs;

	}

	/**

	 * Converts a String of hex characters into an array of bytes.

	 * 

	 * @param s

	 *            A string of hex characters (upper case or lower) of even

	 *            length.

	 * @param out

	 *            A byte array of length at least s.length()/2 + off

	 * @param off

	 *            The first byte to write of the array

	 */

	public static final void hexToBytes(String s, byte[] out, int off)

		throws NumberFormatException, IndexOutOfBoundsException {

		int slen = s.length();

		if ((slen % 2) != 0) {

			s = '0' + s;

		}

		if (out.length < off + slen / 2) {

			throw new IndexOutOfBoundsException(

				"Output buffer too small for input ("

					+ out.length

					+ "<"

					+ off

					+ slen / 2

					+ ")");

		}

		// Safe to assume the string is even length

		byte b1, b2;

		for (int i = 0; i < slen; i += 2) {

			b1 = (byte) Character.digit(s.charAt(i), 16);

			b2 = (byte) Character.digit(s.charAt(i + 1), 16);

			if (b1 < 0 || b2 < 0) {

				throw new NumberFormatException();

			}

			out[off + i / 2] = (byte) (b1 << 4 | b2);

		}

	}

	/**

	 * Pack the bits in ba into a byte[].

	 */

	public final static byte[] bitsToBytes(BitSet ba, int size) {

		int bytesAlloc = countBytesForBits(size);

		byte[] b = new byte[bytesAlloc];

		StringBuffer sb = new StringBuffer();

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

			short s = 0;

			for(int j=0;j<8;j++) {

				int idx = i*8+j;

				boolean val = 

					idx > size ? false :

						ba.get(idx);

				s |= val ? (1<<j) : 0;

				sb.append(val ? '1' : '0');

			}

			if(s > 255) throw new IllegalStateException("WTF? s = "+s);

			b[i] = (byte)s;

		}

		return b;

	}

	/**

	 * Pack the bits in ba into a byte[] then convert that

	 * to a hex string and return it.

	 */

	public final static String bitsToHexString(BitSet ba, int size) {

		return bytesToHex(bitsToBytes(ba, size));

	}

	/**

	 * @return the number of bytes required to represent the

	 * bitset

	 */

	public static int countBytesForBits(int size) {

		// Brackets matter here! == takes precedence over the rest

		return (size/8) + ((size % 8) == 0 ? 0:1);

	}

	/**

	 * Read bits from a byte array into a bitset

	 * @param b the byte[] to read from

	 * @param ba the bitset to write to

	 */

	public static void bytesToBits(byte[] b, BitSet ba, int maxSize) {