Application: gvSIG desktop » gvSIG data provider for DWG

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

  <packaging>jar</packaging>

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

  <description>

Library for read-only access DWG files

Supported versions:

- v12

- v14

- v15

- v2004

  </description>

  <parent>

      <groupId>org.gvsig</groupId>

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

      <version>2.0.32</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.projection.api</artifactId>

      <scope>compile</scope>

    </dependency>

    <dependency>

        <groupId>org.gvsig</groupId>

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

        <scope>compile</scope>

    </dependency>

  </dependencies>

</project>

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

		int x = 0;

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

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

				if(x > maxSize) break;

				int mask = 1 << j;

				boolean value = (mask & b[i]) != 0;

				ba.set(x, value);

				x++;

			}

		}

	}

	/**

	 * Read a hex string of bits and write it into a bitset

	 * @param s hex string of the stored bits

	 * @param ba the bitset to store the bits in

	 * @param length the maximum number of bits to store 

	 */

	public static void hexToBits(String s, BitSet ba, int length) {

		byte[] b = hexToBytes(s);

		bytesToBits(b, ba, length);

	}

}

/* 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.lang.Math;

/**

 * This class allows to apply the extrusion transformation of Autocad given by an array

 * of doubles to a point given by an array of doubles too. 

 * 

 * @author azabala

 */

/*

 * The maths behind all this stuff, and the reasons to do this could be complex.

 * 

 * Some links:

 * http://www.autodesk.com/techpubs/autocad/acadr14/dxf/object_coordinate_systems_40ocs41_al_u05_c.htm

 * http://www.autodesk.com/techpubs/autocad/acadr14/dxf/arbitrary_axis_algorithm_al_u05_c.htm 

 * http://personales.unican.es/togoresr/Sco-en.html

 * 

 * In ACAD, 3D entities has their coordinates in World Coordinate System (WCS: utm, etc.)

 * but 2D entities has their coordinates in an Object Coordinate System (OCS).

 * 

 * To work with the coordinates saved in the file, we must to transform them (extrude) from OCS

 * to WCS

 * 

 * */

public class AcadExtrusionCalculator {

	public static Matrix4D computeTransform(double[] extrusion, double[] coord)

    {

        Vector3D Ax = null;

        if(extrusion[0] == 0d && extrusion[1] == 0d && extrusion[2] > 0d && coord[2] == 0d)

        	return null;

        if((extrusion[0] >= 0f ? extrusion[0]:-extrusion[0]) < 0.015625F

        		&&

            (extrusion[1] >= 0f ? extrusion[1]:-extrusion[1]) < 0.015625F){

        	Ax = new Vector3D(extrusion[2], 0f, -extrusion[0]);

         }else{

        	 Ax = new Vector3D(-extrusion[1],extrusion[0], 0f);

         }

        double len = Ax.length();

        Ax.scale(1d / len);

        Vector3D upward = new Vector3D(extrusion[0], extrusion[1], extrusion[2]);

        Vector3D Ay = upward.cross(Ax);

        Matrix4D aaa = new Matrix4D(Ax.x, Ay.x, upward.x, coord[2] * upward.x, 

  										Ax.y, Ay.y, upward.y, coord[2] * upward.y,

  										Ax.z, Ay.z, upward.z, coord[2] * upward.z, 

  											0.0F, 0.0F, 0.0F, 1.0F);

        //Creo que la transformacion comentada es para pasar de WCS a OCS, y no al reves

        /*

        Matrix4D aaa = new Matrix4D(Ax.x, Ax.y, Ax.z, 0f, 

									Ay.x, Ay.y, Ay.z, 0f,

									upward.x, upward.y, upward.z, 0f,

									coord[2] * upward.x, coord[2] * upward.y, coord[2] * upward.z, 1f);

        */

        return aaa;

    }

	public static double[] extrude2(double[] coord_in, double[] xtru){

		//antes de cambiar el plano, aplicamos una extrusion con valor

		//la altura del punto

//		coord_in[0] += (xtru[0] * coord_in[2]);

//		coord_in[1] += (xtru[1] * coord_in[2]);

//		coord_in[2] += (xtru[2] * coord_in[2]);

		Matrix4D transform = computeTransform(xtru, coord_in);

		if(transform == null)//xtru es el eje Z

			return coord_in;

		Point3D p = new Point3D(coord_in[0], coord_in[1], coord_in[2]);

		transform.transform(p);

		return new double[]{p.x, p.y, p.z};

	}

	/*

   llamamos a finalConv, y este llama a extrude internamente

    static DrawAble finalConv(DrawAble dl, DxfEntity entity, boolean doTransform)

    {

        if(dl == null)

            return null;

        DrawAble dr;

        if(doTransform)

        {

            if(entity.getExtrusion() != 0.0F)

                dr = dl.extrude(entity.getExtrusion());

            else

                dr = dl;

            Matrix4D mat = entity.calcArbitMat();

            if(mat != null)

                dr.transformBy(mat);

        } else

        if(entity.getExtrusion() != 0.0F)

            dr = dl.extrude(entity.getExtrusion(), entity.getUpwardVector());

        else

            dr = dl;

        return dr;

    }

     public DrawAble extrude(float dist, Vector3D up)

    {

        if(dist == 0.0F)

            return this;

        Vector3D ex = new Vector3D(dist * up.x, dist * up.y, dist * up.z);

        DrawSet set = new DrawSet(2 + nrPoints);

        DrawLines second = new DrawLines(nrPoints);

        set.setLayer(super.layer);

        set.setColor(super.color);

        second.setLayer(super.layer);

        second.setColor(super.color);

        set.addDrawable(this);

        for(int i = 0; i < nrPoints; i++)

        {

            second.addPoint(line[i].x + ex.x, line[i].y + ex.y, line[i].z + ex.z);

            DrawLines conn = new DrawLines(2);

            conn.setLayer(super.layer);

            conn.setColor(super.color);

            conn.addPoint(line[i]);

            conn.addPoint(second.line[i]);

            set.addDrawable(conn);

        }

        if(isClosed)

            second.close();

        set.addDrawable(second);

        return set;

    }

*/

}

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

 */

package org.gvsig.dwg.lib.util;

import java.math.BigInteger;

/**

 * Clase que engloba m?todos para trabajar con bytes. 

 *

 * @author Vicente Caballero Navarro

 */

public class ByteUtils {

	public static final int SIZE_BOOL = 1;

	public static final int SIZE_SHORT = 2;

	public static final int SIZE_INT = 4;

	public static final int SIZE_LONG = 8;

	public static final int SIZE_DOUBLE = 8;

	/** A nibble->char mapping for printing out bytes. */

	public static final char[] digits = {

			'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd',

			'e', 'f'

		};

	/**

	 * Return the <code>int</code> represented by the bytes in

	 * <code>data</code> staring at offset <code>offset[0]</code>.

	 *

	 * @param data the array from which to read

	 * @param offset A single element array whose first element is the index in

	 * 		  data from which to begin reading on function entry, and which on

	 * 		  function exit has been incremented by the number of bytes read.

	 *

	 * @return the value of the <code>int</code> decoded

	 */

	public static final int bytesToInt(byte[] data, int[] offset) {

		/**

		 * TODO: We use network-order within OceanStore, but temporarily

		 * supporting intel-order to work with some JNI code until JNI code is

		 * set to interoperate with network-order.

		 */

		int result = 0;

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

			result <<= 8;

			result |= byteToUnsignedInt(data[offset[0]++]);

		}

		return result;

	}

	/**

	 * Write the bytes representing <code>i</code> into the byte array

	 * <code>data</code>, starting at index <code>offset [0]</code>, and

	 * increment <code>offset [0]</code> by the number of bytes written; if

	 * <code>data == null</code>, increment <code>offset [0]</code> by the

	 * number of bytes that would have been written otherwise.

	 *

	 * @param i the <code>int</code> to encode

	 * @param data The byte array to store into, or <code>null</code>.

	 * @param offset A single element array whose first element is the index in

	 * 		  data to begin writing at on function entry, and which on

	 * 		  function exit has been incremented by the number of bytes

	 * 		  written.

	 */

	public static final void intToBytes(int i, byte[] data, int[] offset) {

		/**

		 * TODO: We use network-order within OceanStore, but temporarily

		 * supporting intel-order to work with some JNI code until JNI code is

		 * set to interoperate with network-order.

		 */

		if (data != null) {

			for (int j = (offset[0] + SIZE_INT) - 1; j >= offset[0]; --j) {

				data[j] = (byte) i;

				i >>= 8;

			}

		}

		offset[0] += SIZE_INT;

	}

	/**

	 * Return the <code>short</code> represented by the bytes in

	 * <code>data</code> staring at offset <code>offset[0]</code>.

	 *

	 * @param data the array from which to read

	 * @param offset A single element array whose first element is the index in

	 * 		  data from which to begin reading on function entry, and which on

	 * 		  function exit has been incremented by the number of bytes read.

	 *

	 * @return the value of the <code>short</code> decoded

	 */

	public static final short bytesToShort(byte[] data, int[] offset) {

		/**

		 * TODO: We use network-order within OceanStore, but temporarily

		 * supporting intel-order to work with some JNI code until JNI code is

		 * set to interoperate with network-order.

		 */

		short result = 0;

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

			result <<= 8;

			result |= (short) byteToUnsignedInt(data[offset[0]++]);

		}

		return result;

	}

	/**

	 * Write the bytes representing <code>s</code> into the byte array

	 * <code>data</code>, starting at index <code>offset [0]</code>, and

	 * increment <code>offset [0]</code> by the number of bytes written; if

	 * <code>data == null</code>, increment <code>offset [0]</code> by the

	 * number of bytes that would have been written otherwise.

	 *

	 * @param s the <code>short</code> to encode

	 * @param data The byte array to store into, or <code>null</code>.

	 * @param offset A single element array whose first element is the index in

	 * 		  data to begin writing at on function entry, and which on

	 * 		  function exit has been incremented by the number of bytes

	 * 		  written.

	 */

	public static final void shortToBytes(short s, byte[] data, int[] offset) {

		/**

		 * TODO: We use network-order within OceanStore, but temporarily

		 * supporting intel-order to work with some JNI code until JNI code is

		 * set to interoperate with network-order.

		 */

		if (data != null) {

			data[offset[0] + 1] = (byte) s;

			data[offset[0]] = (byte) (s >> 8);

		}

		offset[0] += SIZE_SHORT;

	}

	/**

	 * Return the <code>long</code> represented by the bytes in

	 * <code>data</code> staring at offset <code>offset[0]</code>.

	 *

	 * @param data the array from which to read

	 * @param offset A single element array whose first element is the index in

	 * 		  data from which to begin reading on  function entry, and which

	 * 		  on function exit has been incremented by the number of bytes

	 * 		  read.

	 *

	 * @return the value of the <code>long</code> decoded

	 */

	public static final long bytesToLong(byte[] data, int[] offset) {

		long result = 0;

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

			result <<= 8;

			int res = byteToUnsignedInt(data[offset[0]++]);

			result = result | res;

		}

		return result;

	}

	/**

	 * Write the bytes representing <code>l</code> into the byte array

	 * <code>data</code>, starting at index <code>offset [0]</code>, and

	 * increment <code>offset [0]</code> by the number of bytes written; if

	 * <code>data == null</code>, increment <code>offset [0]</code> by the

	 * number of bytes that would have been written otherwise.

	 *

	 * @param l the <code>long</code> to encode

	 * @param data The byte array to store into, or <code>null</code>.

	 * @param offset A single element array whose first element is the index in

	 * 		  data to begin writing at on function entry, and which on

	 * 		  function exit has been incremented by the number of bytes

	 * 		  written.

	 */

	public static final void longToBytes(long l, byte[] data, int[] offset) {

		/**

		 * TODO: We use network-order within OceanStore, but temporarily

		 * supporting intel-order to work with some JNI code until JNI code is

		 * set to interoperate with network-order.

		 */

		if (data != null) {

			for (int j = (offset[0] + SIZE_LONG) - 1; j >= offset[0]; --j) {

				data[j] = (byte) l;

				l >>= 8;

			}

		}

		offset[0] += SIZE_LONG;

	}

	/**

	 * Return the <code>double</code> represented by the bytes in

	 * <code>data</code> staring at offset <code>offset[0]</code>.

	 *

	 * @param data the array from which to read

	 * @param offset A single element array whose first element is the index in

	 * 		  data from which to begin reading on  function entry, and which

	 * 		  on function exit has been incremented by the number of bytes

	 * 		  read.

	 *

	 * @return the value of the <code>double</code> decoded

	 */

	public static final double bytesToDouble(byte[] data, int[] offset) {

		long bits = bytesToLong(data, offset);

		return Double.longBitsToDouble(bits);

	}

	/**

	 * Write the bytes representing <code>d</code> into the byte array

	 * <code>data</code>, starting at index <code>offset [0]</code>, and

	 * increment <code>offset [0]</code> by the number of bytes written; if

	 * <code>data == null</code>, increment <code>offset [0]</code> by the

	 * number of bytes that would have been written otherwise.

	 *

	 * @param d the <code>double</code> to encode

	 * @param data The byte array to store into, or <code>null</code>.

	 * @param offset A single element array whose first element is the index in

	 * 		  data to begin writing at on function entry, and which on

	 * 		  function exit has been incremented by the number of bytes

	 * 		  written.

	 */

	public static final void doubleToBytes(double d, byte[] data, int[] offset) {

		long bits = Double.doubleToLongBits(d);

		longToBytes(bits, data, offset);

	}

	/**

	 * Return the <code>String</code> represented by the bytes in

	 * <code>data</code> staring at offset <code>offset[0]</code>. This method

	 * relies on the user using the corresponding <code>stringToBytes</code>

	 * method to encode the <code>String</code>, so that it may properly

	 * retrieve the <code>String</code> length.

	 *

	 * @param data the array from which to read

	 * @param offset A single element array whose first element is the index in

	 * 		  data from which to begin reading on function entry, and which on

	 * 		  function exit has been incremented by the number of bytes read.

	 *

	 * @return the value of the <code>String</code> decoded

	 */

	public static final String bytesToString(byte[] data, int[] offset) {

		offset[0] = 0;

		int length = bytesToInt(data, offset);

		String st = null;

		if ((length < 0) || (length > data.length)) {

			st = new String(data);

		} else {

			st = new String(data, offset[0], length);

		}

		offset[0] += length;

		return st;

	}

	/**

	 * Write the bytes representing <code>s</code> into the byte array

	 * <code>data</code>, starting at index <code>offset [0]</code>, and

	 * increment <code>offset [0]</code> by the number of bytes written; if

	 * <code>data == null</code>, increment <code>offset [0]</code> by the

	 * number of bytes that would have been written otherwise.

	 *

	 * @param s the <code>String</code> to encode

	 * @param data The byte array to store into, or <code>null</code>.

	 * @param offset A single element array whose first element is the index in

	 * 		  data to begin writing at on function entry, and which on

	 * 		  function exit has been incremented by the number of bytes

	 * 		  written.

	 */

	public static final void stringToBytes(String s, byte[] data, int[] offset) {

		byte[] s_bytes = s.getBytes();

		if (data != null) {

			intToBytes(s_bytes.length, data, offset);

			memcpy(data, offset[0], s_bytes, 0, s_bytes.length);

		} else {

			offset[0] += SIZE_INT;

		}

		offset[0] += s_bytes.length;

	}

	/**

	 * Return the <code>boolean</code> represented by the bytes in

	 * <code>data</code> staring at offset <code>offset[0]</code>.

	 *

	 * @param data the array from which to read

	 * @param offset A single element array whose first element is the index in

	 * 		  data from which to begin reading on  function entry, and which

	 * 		  on function exit has been incremented by the number of bytes

	 * 		  read.

	 *

	 * @return the value of the <code>boolean</code> decoded