Application: gvSIG desktop » gvSIG data provider for DWG

package org.gvsig.dwg.lib;

import java.io.File;

import java.io.IOException;

import java.net.URL;

import junit.framework.TestCase;

public class DwgFileTest extends TestCase {

	private File baseDataPath;

	protected void setUp() throws Exception {

		super.setUp();

		URL url = this.getClass().getResource("data");

		if (url == null) {

			throw new Exception("Can't find 'data' dir");

		}

		baseDataPath = new File(url.getFile());

		if (!baseDataPath.exists()) {

			throw new Exception("Can't find 'data' dir");

		}

	}

	protected void tearDown() throws Exception {

		super.tearDown();

	}

	public void test1() throws IOException, DwgVersionNotSupportedException {

//		String fileName = baseDataPath.getAbsolutePath()+"/Un punto.dwg";

//		DwgFile dwg = new DwgFile(fileName);

//

//		dwg.read();

//		dwg.calculateGisModelDwgPolylines();

//		dwg.blockManagement();

//		LinkedList dwgObjects = dwg.getDwgObjects();

	}

	public void test2() throws RuntimeException, CorruptedDwgEntityException{

        //Dwg Object that is supposed to be

        //an LWPOLYLINE in V14 version

		/*

        int[] data = new int[]{61,64,64,183,19,227,104,16

                            ,0,5,8,59,72,32,252,47,90,142,

                            234,145,50,10,71,11,213,36,229,

                            162,130,10,228,126,23,174,130,

                            145,50,15,98,141,196,244,229,

                            162,130,12,126,23,169,66,58,

                            145,50,12,47,90,138,68,229,

                            162,130,8,0,0,4,7,74,137,50,

                            15,177,66,231,252,221,162,130,

                            9,130,151,21,242,151,21,190,

                            8,21,8,56};

         */

//		int[] data = new int[]{62,128,64,71,99,

//							   40,48,0,5,8,27,72,

//							   100,126,23,169,68,

//							   178,105,50,13,114,

//							   63,11,82,165,162,130,

//							   13,114,63,11,210,138,

//							   105,50,8,173,114,59,

//							   138,205,162,130,15,98,

//							   141,192,241,58,105,50,

//							   11,51,51,52,178,229,162,

//							   130,14,110,102,98,97,234,

//							   105,50,11,51,51,52,179,21,

//							   162,130,10,149,192,240,42,

//							   162,105,50,14,189,27,131,

//							   107,69,162,130,14,31,169,

//							   66,227,74,105,50,9,240,86,

//							   185,27,117,162,130,11,59,

//							   51,51,52,234,105,50,13,114,

//							   63,11,83,85,162,130,9,74,228,

//							   126,22,186,105,50,11,51,51,50,

//							   51,53,162,130,11,137,232,82,190,

//							   58,105,50,9,74,228,122,147,13,162,

//							   130,11,137,232,82,189,106,105,50,9,

//							   74,228,122,146,213,162,130,9,74,228,122,20,202,105,50,12,126,23,171,194,173,162,130,12,126,23,169,68,178,105,50,13,114,63,11,82,165,162,130,9,130,151,22,10,136,182,8,21,8,120};

//        //1er intento: suponemos que la LWPOLYLINE cumple la especificaci?n

//        //a rajatabla

//        int bitPos = 0;

//        List val = DwgUtil.getBitShort(data, bitPos);

//        bitPos = ((Integer) val.get(0)).intValue();

//        int type = ((Integer) val.get(1)).intValue();

//        System.out.println("type = " + type);

//

//        DwgHandleReference hr = new DwgHandleReference();

//        bitPos = hr.read(data, bitPos);

//        System.out.println("handle, code="+

//                    hr.getCode()+

//                    " ,offset="+

//                    hr.getOffset());

//

//        //Ahora pasamos a la extended data

//        val = DwgUtil.getBitShort(data, bitPos);

//        bitPos = ((Integer) val.get(0)).intValue();

//        int extendedDataSize = ((Integer) val.get(1)).intValue();

//        System.out.println("EED size="+extendedDataSize);

//        //como el size es 0, me lo salto

//

//        //ver si tiene datos graficos

//        val = DwgUtil.testBit(data, bitPos);

//        bitPos = ((Integer) val.get(0)).intValue();

//        boolean hasGraphicsData = ((Boolean) val.get(1))

//                .booleanValue();

//        System.out.println("graphics = "+hasGraphicsData);

//

//        //como se que no hay graphics me lo salto

//        //tama?o en bits

//        val = DwgUtil.getRawLong(data, bitPos);

//        bitPos = ((Integer) val.get(0)).intValue();

//        int sizeInBits = ((Integer) val.get(1)).intValue();

//        System.out.println("sizeInBits = "+sizeInBits);

//

//        /*

//         * Ahora, lo que viene es lo que en la spec se dice

//         * "Common entity data". Revisar bien pues PythonCAD no lo lee

//         * como en la spec.

//         *

//         * pag 42.

//          R13-R14 Only:

//          	RL	:	Size of object data in bits

//          	6B	:	Flags (FEDCBA)

//          	6B	:	Common parameters (CCSSII)

//          	Segun esto, deberia leer 6 bits y 6 bits

//

//          	FLAGS

//	      	Mas adelante (pag 43), dice:

//	      	DC	:	This is the number of reactors attached to an

//	      	entity as a bitshort.

//	      	This feature may have been dormant in R13,

//	      	but it appears in R14, and in files saved as R13 by R14.

//

//	      	Ahora bien, pythoncad las est? leyendo como bitLong

//          	?En que quedamos, son 2 bits, 1 bitLong o 1 bitShort?

//          	TODO REVISAR

//

//          	COMMON PARAMETERS

//          	Al principio, dice que son 6 bits (CC, SS, II)

//          	pero luego dice (pag 43):

//          	CC	:	Color bitshort

//          	SS	:	Linetype scale bitdouble

//          	II	:	"Invisible" flag bitshort

//

//			Pythoncad, en vez de como 2 bits, los est? leyendo

//			como BitShort, BitDouble y BitShort

//

//         * */

//

//        Integer mode = (Integer) DwgUtil.getBits(data, 2, bitPos);

//		bitPos += 2;

//		System.out.println("mode = "+mode);

//

//	/*

//		val = DwgUtil.getBitLong(data, bitPos);

//		bitPos = ((Integer) val.get(0)).intValue();

//		int rnum = ((Integer) val.get(1)).intValue();

//		System.out.println("numReactors = "+rnum);

//*/

//		val = DwgUtil.getBitShort(data, bitPos);

//		bitPos = ((Integer) val.get(0)).intValue();

//		int rnum = ((Integer) val.get(1)).intValue();

//		System.out.println("numReactors = "+rnum);

//

//

//		val = DwgUtil.testBit(data, bitPos);

//		bitPos = ((Integer) val.get(0)).intValue();

//		boolean isLyrByLineType = ((Boolean) val.get(1)).booleanValue();

//		System.out.println("isLyrByLineType="+isLyrByLineType);

//

//		val = DwgUtil.testBit(data, bitPos);

//		bitPos = ((Integer) val.get(0)).intValue();

//		boolean noLinks = ((Boolean) val.get(1)).booleanValue();

//		System.out.println("noLinks="+noLinks);

//

//

//		val = DwgUtil.getBitShort(data, bitPos);

//		bitPos = ((Integer) val.get(0)).intValue();

//		int color = ((Integer) val.get(1)).intValue();

//		System.out.println("color="+color);

//

//

//		val = DwgUtil.getBitDouble(data, bitPos);

//		bitPos = ((Integer) val.get(0)).intValue();

//		float ltscale = ((Double) val.get(1)).floatValue();

//		System.out.println("ltscale="+ltscale);

//

//		val = DwgUtil.getBitShort(data, bitPos);

//		bitPos = ((Integer) val.get(0)).intValue();

//		int invis = ((Integer) val.get(1)).intValue();

//		System.out.println("invis="+invis);

//

//		val = DwgUtil.getBitShort(data, bitPos);

//		bitPos = ((Integer) val.get(0)).intValue();

//		int flag = ((Integer) val.get(1)).intValue();

//		System.out.println("flag="+flag);

//

//		double dVal = 0d;

//		if((flag & 0x4) > 0){

//			val = DwgUtil.getBitDouble(data, bitPos);

//			bitPos = ((Integer) val.get(0)).intValue();

//			dVal = ((Double) val.get(1)).doubleValue();

//		}

//		System.out.println("constWidth="+dVal);

//

//		dVal = 0d;

//		if((flag & 0x8) > 0){

//			val = DwgUtil.getBitDouble(data, bitPos);

//			bitPos = ((Integer) val.get(0)).intValue();

//			dVal = ((Double) val.get(1)).doubleValue();

//		}

//		System.out.println("elevation="+dVal);

//

//		dVal = 0d;

//		if ((flag & 0x2) > 0){

//			val = DwgUtil.getBitDouble(data, bitPos);

//			bitPos = ((Integer) val.get(0)).intValue();

//			dVal = ((Double) val.get(1)).doubleValue();

//		}

//		System.out.println("thickness="+dVal);

//

//		double x, y, z ;

//		x = 0d;

//		y = 0d;

//		z = 0d;

//

//		if ((flag & 0x1) > 0){

//			val = DwgUtil.getBitDouble(data, bitPos);

//			bitPos = ((Integer) val.get(0)).intValue();

//			x = ((Double) val.get(1)).doubleValue();

//

//			val = DwgUtil.getBitDouble(data, bitPos);

//			bitPos = ((Integer) val.get(0)).intValue();

//			y = ((Double) val.get(1)).doubleValue();

//

//			val = DwgUtil.getBitDouble(data, bitPos);

//			bitPos = ((Integer) val.get(0)).intValue();

//			z = ((Double) val.get(1)).doubleValue();

//		}

//		System.out.println("normal="+x+","+y+","+z);

//

//		val = DwgUtil.getBitLong(data, bitPos);

//		bitPos = ((Integer) val.get(0)).intValue();

//		int np = ((Integer) val.get(1)).intValue();

//		System.out.println("numPoints="+np);

//

//		int nb = 0;

//		if((flag & 0x10) > 0){

//			val = DwgUtil.getBitLong(data, bitPos);

//			bitPos = ((Integer) val.get(0)).intValue();

//			nb = ((Integer) val.get(1)).intValue();

//		}

//		System.out.println("numBulges="+nb);

//		int nw = 0;

//		if((flag & 0x20) > 0){

//			val = DwgUtil.getBitLong(data, bitPos);

//			bitPos = ((Integer) val.get(0)).intValue();

//			nw = ((Integer) val.get(1)).intValue();

//		}

//		System.out.println("numWidths="+nw);

//		if(np > 0){

//			Point2D[] points = new Point2D[np];

//			for(int i = 0; i < np; i++){

//				val = DwgUtil.getRawDouble(data, bitPos);

//				bitPos = ((Integer) val.get(0)).intValue();

//				x = ((Double) val.get(1)).doubleValue();

//

//				val = DwgUtil.getRawDouble(data, bitPos);

//				bitPos = ((Integer) val.get(0)).intValue();

//				y = ((Double) val.get(1)).doubleValue();

//

//				points[i] = new Point2D.Double(x, y);

//				System.out.println("Punto"+i+"="+x+","+y);

//			}//for

//		}//if np

//

//		if(nb > 0){

//			double[] bulges = new double[nb];

//			for(int i = 0; i < nb; i++){

//				val = DwgUtil.getRawDouble(data, bitPos);

//				bitPos = ((Integer) val.get(0)).intValue();

//				bulges[i] = ((Double) val.get(1)).doubleValue();

//				System.out.println("Bulge"+i+"="+bulges[i]);

//			}//for

//

//		}//if nb

//

//		if(nw > 0){

//			double[][] widths = new double[nw][2];

//			for(int i = 0; i < nw; i++){

//				val = DwgUtil.getBitDouble(data, bitPos);

//				bitPos = ((Integer) val.get(0)).intValue();

//				double sw = ((Double) val.get(1)).doubleValue();

//

//				val = DwgUtil.getBitDouble(data, bitPos);

//				bitPos = ((Integer) val.get(0)).intValue();

//				double ew = ((Double) val.get(1)).doubleValue();

//

//				widths[i][0] = sw;

//				widths[i][1] = ew;

//				System.out.println("Width"+i+"="+sw+","+ew);

//			}//for

//		}

     }

	public void test3(){

		//test of extrusion

		double[] coord = null;

		double[] extrusion = null;

		double[] extrusion2 = new double[]{0, 0, 1};

		coord = new double[]{790089.65, 4477974.75, 9.560000000114087};

		extrusion = new double[]{-0.5037965987025721, 0.07005064807841195, 0.8609772899673451};

		//1. algoritmo original, vector normal distinto

//		double[] newCoord = AcadExtrusionCalculator.extrude(coord, extrusion);

//		newCoord = AcadExtrusionCalculator.extrude3(coord, extrusion);

//

		//2? ahora con vector normal coincidente con eje Z

//		newCoord = AcadExtrusionCalculator.extrude(coord, extrusion2);

//		newCoord = AcadExtrusionCalculator.extrude3(coord, extrusion2);

	}

}

/*

 * Created on 08-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: DwgTestSuite.java 28970 2009-05-25 13:27:14Z jmvivo $

* $Log$

* Revision 1.1.2.1  2007-02-28 07:35:10  jmvivo

* Actualizado desde el HEAD.

*

* Revision 1.1  2007/02/08 20:27:57  azabala

* *** empty log message ***

*

*

*/

package org.gvsig.dwg.lib;

import junit.framework.Test;

import junit.framework.TestSuite;

public class DwgTestSuite {

	public static Test suite() {

		TestSuite suite = new TestSuite("Test for com.iver.cit.jdwglib.dwg");

		//$JUnit-BEGIN$

		suite.addTestSuite(DwgFileTest.class);

		//$JUnit-END$

		return suite;

	}

}

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

}

package org.gvsig.dwg.lib.util;

/**

 *  4x4dim double matrix used for perspective transformations.

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

 *

 */

public final class Matrix4D {

  static private final double DEG2RAD = Math.PI/180.0;  // conversion from degree to radians

  public double xx, xy, xz, xw,     // 1st row

			   yx, yy, yz, yw,     // 2nd row

			   zx, zy, zz, zw,     // 3rd row

			   wx, wy, wz, ww;     // 4th row

  /**

   *  Create identity matrix.

   */

  public Matrix4D() {

	// set to identity mat

	xx = yy = zz = ww = 1f;

  }

  /**

   *  Copy constructor.

   *  @param  m   matrix to copy

   */

  public Matrix4D(Matrix4D m) {

	xx = m.xx;

	xy = m.xy;

	xz = m.xz;

	xw = m.xw;

	yx = m.yx;

	yy = m.yy;

	yz = m.yz;

	yw = m.yw;

	zx = m.zx;

	zy = m.zy;

	zz = m.zz;

	zw = m.zw;

	wx = m.wx;

	wy = m.wy;

	wz = m.wz;

	ww = m.ww;

  }

  /**

   *  @param  mxx     1st elem in 1st row

   *  @param  mxy     2nd elem in 1st row

   *  @param  mxz     3rd elem in 1st row

   *  @param  mxw     4th elem in 1st row

   *  @param  myx     1st elem in 2nd row

   *  @param  myy     2nd elem in 2nd row

   *  @param  myz     3rd elem in 2nd row

   *  @param  myw     4th elem in 2nd row

   *  @param  mzx     1st elem in 3rd row

   *  @param  mzy     2nd elem in 3rd row

   *  @param  mzz     3rd elem in 3rd row

   *  @param  mzw     4th elem in 3rd row

   *  @param  mwx     1st elem in 4th row

   *  @param  mwy     2nd elem in 4th row

   *  @param  mwz     3rd elem in 4th row

   *  @param  mww     4th elem in 4th row

   */

  public Matrix4D(double mxx, double mxy, double mxz, double mxw,

		  double myx, double myy, double myz, double myw,

		  double mzx, double mzy, double mzz, double mzw,

		  double mwx, double mwy, double mwz, double mww) {

	xx = mxx;

	xy = mxy;

	xz = mxz;

	xw = mxw;

	yx = myx;

	yy = myy;

	yz = myz;

	yw = myw;

	zx = mzx;

	zy = mzy;

	zz = mzz;

	zw = mzw;

	wx = mwx;

	wy = mwy;

	wz = mwz;

	ww = mww;

  }

  /**

   *  Reset to identity

   */

  public void identity() {

	xx = yy = zz = ww = 1f;

	xy = xz = xw =

	  yx = yz = yw =

	  zx = zy = zw =

	  wx = wy = wz = 0f;

  }

  /**

   *  Transponize.

   */

  public void transponize() {

	// switch rows and columns

	double t;

	t = xy; xy = yx; yx = t;

	t = xz; xz = zx; zx = t;

	t = xw; xw = wx; wx = t;

	t = yz; yz = zy; zy = t;

	t = yw; yw = wy; wy = t;

	t = zw; zw = wz; wz = t;

  }

  /**

   *  Matrix multiplication of vector.

   *  @param  v   vector to transform

   *  @return transformed vector

   */

  public Vector3D mult(Vector3D v) {

	return new Vector3D(xx*v.x + xy*v.y + xz*v.z,

			yx*v.x + yy*v.y + yz*v.z,

			zx*v.x + zy*v.y + zz*v.z);

  }

  /**

   *  Transformation of 1 vector.

   *  @param  v   vector to transform

   */

  public void transform(Vector3D v) {

	double x = xx*v.x + xy*v.y + xz*v.z,

		  y = yx*v.x + yy*v.y + yz*v.z,

		  z = zx*v.x + zy*v.y + zz*v.z;

	v.x = x;

	v.y = y;

	v.z = z;

  }

  /**

   *  Matrix multiplication of point.

   *  @param  p    point to transform

   *  @return transformed point

   */

  public Point3D mult(Point3D p) {

	Point3D ret = new Point3D(xx*p.x + xy*p.y + xz*p.z + xw,

				  yx*p.x + yy*p.y + yz*p.z + yw,

				  zx*p.x + zy*p.y + zz*p.z + zw);

	ret.scale(1f/(wx*p.x + wy*p.y + wz*p.z + ww));

	return ret;

  }

  /**

   *  Transformation of 1 point.

   *  @param  p   point to transform

   */

  public void transform(Point3D p) {

	double  x = xx*p.x + xy*p.y + xz*p.z + xw,

		   y = yx*p.x + yy*p.y + yz*p.z + yw,

		   z = zx*p.x + zy*p.y + zz*p.z + zw,

		   w = wx*p.x + wy*p.y + wz*p.z + ww;

	p.x = x/w;

	p.y = y/w;

	p.z = z/w;

  }

  /**Transformacion de un punto considerando solo el plano horizontal

   */

   public void transformXY(Point3D p){

		double  x = xx*p.x + xy*p.y+ xw,

		y = yx*p.x + yy*p.y + yw,

		w = wx*p.x + wy*p.y + ww;

		p.x = x/w;

		p.y = y/w;

   }

  /**

   *  Matrix multiplication.

   *  @param  m   matrix to multiply with

   *  @return this * m

   */

  public Matrix4D mult(Matrix4D m) {

	if (m != null) {

	  return new Matrix4D(xx*m.xx + xy*m.yx + xz*m.zx + xw*m.wx,

			  xx*m.xy + xy*m.yy + xz*m.zy + xw*m.wy,

			  xx*m.xz + xy*m.yz + xz*m.zz + xw*m.wz,

			  xx*m.xw + xy*m.yw + xz*m.zw + xw*m.ww,

			  yx*m.xx + yy*m.yx + yz*m.zx + yw*m.wx,

			  yx*m.xy + yy*m.yy + yz*m.zy + yw*m.wy,

			  yx*m.xz + yy*m.yz + yz*m.zz + yw*m.wz,

			  yx*m.xw + yy*m.yw + yz*m.zw + yw*m.ww,

			  zx*m.xx + zy*m.yx + zz*m.zx + zw*m.wx,

			  zx*m.xy + zy*m.yy + zz*m.zy + zw*m.wy,

			  zx*m.xz + zy*m.yz + zz*m.zz + zw*m.wz,

			  zx*m.xw + zy*m.yw + zz*m.zw + zw*m.ww,

			  wx*m.xx + wy*m.yx + wz*m.zx + ww*m.wx,

			  wx*m.xy + wy*m.yy + wz*m.zy + ww*m.wy,

			  wx*m.xz + wy*m.yz + wz*m.zz + ww*m.wz,

			  wx*m.xw + wy*m.yw + wz*m.zw + ww*m.ww);

	}

	else {

	  return new Matrix4D(this);

	}

  }

  /**

   *  Matrix multiplication.

   *  @param  m  matrix to multply with

   */

  public void multBy(Matrix4D m) {

	double x = xx*m.xx + xy*m.yx + xz*m.zx + xw*m.wx,

		  y = xx*m.xy + xy*m.yy + xz*m.zy + xw*m.wy,

		  z = xx*m.xz + xy*m.yz + xz*m.zz + xw*m.wz,

		  w = xx*m.xw + xy*m.yw + xz*m.zw + xw*m.ww;

	xx = x;

	xy = y;

	xz = z;

	xw = w;

	x = yx*m.xx + yy*m.yx + yz*m.zx + yw*m.wx;

	y = yx*m.xy + yy*m.yy + yz*m.zy + yw*m.wy;

	z = yx*m.xz + yy*m.yz + yz*m.zz + yw*m.wz;

	w = yx*m.xw + yy*m.yw + yz*m.zw + yw*m.ww;

	yx = x;

	yy = y;

	yz = z;

	yw = w;

	x = zx*m.xx + zy*m.yx + zz*m.zx + zw*m.wx;

	y = zx*m.xy + zy*m.yy + zz*m.zy + zw*m.wy;

	z = zx*m.xz + zy*m.yz + zz*m.zz + zw*m.wz;

	w = zx*m.xw + zy*m.yw + zz*m.zw + zw*m.ww;

	zx = x;

	zy = y;

	zz = z;

	zw = w;

	x = wx*m.xx + wy*m.yx + wz*m.zx + ww*m.wx;

	y = wx*m.xy + wy*m.yy + wz*m.zy + ww*m.wy;

	z = wx*m.xz + wy*m.yz + wz*m.zz + ww*m.wz;

	w = wx*m.xw + wy*m.yw + wz*m.zw + ww*m.ww;

	wx = x;

	wy = y;

	wz = z;

	ww = w;

  }

  /**

   *  Matrix multiplication from left.

   *  @param  m  matrix to multiply with.

   */

  public void multLeftBy(Matrix4D m) {

	double x = m.xx*xx + m.xy*yx + m.xz*zx + m.xw*wx,

		  y = m.yx*xx + m.yy*yx + m.yz*zx + m.yw*wx,

		  z = m.zx*xx + m.zy*yx + m.zz*zx + m.zw*wx,

		  w = m.wx*xx + m.wy*yx + m.wz*zx + m.ww*wx;

	xx = x;

	yx = y;

	zx = z;

	wx = w;

	x = m.xx*xy + m.xy*yy + m.xz*zy + m.xw*wy;

	y = m.yx*xy + m.yy*yy + m.yz*zy + m.yw*wy;

	z = m.zx*xy + m.zy*yy + m.zz*zy + m.zw*wy;

	w = m.wx*xy + m.wy*yy + m.wz*zy + m.ww*wy;

	xy = x;

	yy = y;

	zy = z;

	wy = w;

	x = m.xx*xz + m.xy*yz + m.xz*zz + m.xw*wz;

	y = m.yx*xz + m.yy*yz + m.yz*zz + m.yw*wz;

	z = m.zx*xz + m.zy*yz + m.zz*zz + m.zw*wz;

	w = m.wx*xz + m.wy*yz + m.wz*zz + m.ww*wz;

	xz = x;

	yz = y;

	zz = z;

	wz = w;

	x = m.xx*xw + m.xy*yw + m.xz*zw + m.xw*ww;

	y = m.yx*xw + m.yy*yw + m.yz*zw + m.yw*ww;

	z = m.zx*xw + m.zy*yw + m.zz*zw + m.zw*ww;

	w = m.wx*xw + m.wy*yw + m.wz*zw + m.ww*ww;

	xw = x;

	yw = y;

	zw = z;

	ww = w;

  }

  /**

   *  Translate the origin.

   *  @param  x   translation in x

   *  @param  y   translation in y

   *  @param  z   translation in z

   */

  public void translate(double x, double y, double z) {

	xw += x*xx+y*xy+z*xz;

	yw += x*yx+y*yy+z*yz;

	zw += x*zx+y*zy+z*zz;

	ww += x*wx+y*wy+z*wz;

  }

  /**

   *  Translate the origin

   *  @param  v   translation vector

   */

  public void translate(Vector3D v) {

	translate(v.x, v.y, v.z);

  }

  /**

   *  Translate.

   *  @param  x   translation in x

   *  @param  y   translation in y

   *  @param  z   translation in z

   */

  public void translateLeft(double x, double y, double z) {

	if (x != 0f) {

	  xx += x*wx;  xy += x*wy;  xz += x*wz;  xw += x*ww;

	}

	if (y != 0f) {

	  yx += y*wx;  yy += y*wy;  yz += y*wz;  yw += y*ww;

	}

	if (z != 0f) {

	  zx += z*wx;  zy += z*wy;  zz += z*wz;  zw += z*ww;

	}

  }

  /**

   *  Translate the origin

   *  @param  v   tranbslation vector

   */

  public void translateLeft(Vector3D v) {

	translateLeft(v.x, v.y, v.z);

  }

  /**

   *  Move the stuff.

   *  @param  x   translation in x

   *  @param  y   translation in y

   *  @param  z   translation in z

   */

  public void moveBy(double x, double y, double z) {

	if (x != 0f) {

	  xx += x*xw;  yx += x*yw;  zx += x*zw;  wx += x*ww;

	}

	if (y != 0f) {

	  xy += y*xw;  yy += y*yw;  zy += y*zw;  wy += y*ww;

	}

	if (z != 0f) {

	  xz += z*xw;  yz += z*yw;  zz += z*zw;  wz += z*ww;

	}

  }

  /**

   *  Translate the origin

   *  @param  v   translation vector

   */

  public void moveBy(Vector3D v) {

	moveBy(v.x, v.y, v.z);

  }

  /**

   *  Rotate theta degrees about the y axis.

   *  @param  theta  rotation angle in rad

   */

  public void yrot(double theta) {

	if (theta == 0.0) {

	  return;

	}

	double ct = Math.cos(theta);

	double st = -Math.sin(theta);

	double Nx = (double) (xx * ct - zx * st);

	double Nz = (double) (xx * st + zx * ct);

	xx = Nx;

	zx = Nz;

	Nx = (double) (xy * ct - zy * st);

	Nz = (double) (xy * st + zy * ct);

	xy = Nx;

	zy = Nz;

	Nx = (double) (xz * ct - zz * st);

	Nz = (double) (xz * st + zz * ct);

	xz = Nx;

	zz = Nz;

	Nx = (double) (xw * ct - zw * st);

	Nz = (double) (xw * st + zw * ct);

	xw = Nx;

	zw = Nz;

  }

  /**

   *  Rotate theta degrees about the x axis.

   *  @param  theta  rotation angle in rad

   */

  public void xrot(double theta) {

	if (theta == 0.0) {

	  return;

	}

	double ct = Math.cos(theta);

	double st = Math.sin(theta);

	double Ny = (double) (yx * ct - zx * st);

	double Nz = (double) (yx * st + zx * ct);

	yx = Ny;

	zx = Nz;

	Ny = (double) (yy * ct - zy * st);

	Nz = (double) (yy * st + zy * ct);

	yy = Ny;

	zy = Nz;

	Ny = (double) (yz * ct - zz * st);

	Nz = (double) (yz * st + zz * ct);

	yz = Ny;

	zz = Nz;

	Ny = (double) (yw * ct - zw * st);

	Nz = (double) (yw * st + zw * ct);

	yw = Ny;

	zw = Nz;

  }

  /**

   *  Rotate theta degrees about the z axis.

   *  @param  theta  rotation angle in rad

   */

  public void zrot(double theta) {

	if (theta == 0.0) {

	  return;

	}

	double ct = Math.cos(theta);

	double st = Math.sin(theta);

	double Nx = (double) (xx * ct - yx * st);

	double Ny = (double) (xx * st + yx * ct);

	xx = Nx;

	yx = Ny;

	Nx = (double) (xy * ct - yy * st);

	Ny = (double) (xy * st + yy * ct);

	xy = Nx;

	yy = Ny;

	Nx = (double) (xz * ct - yz * st);

	Ny = (double) (xz * st + yz * ct);

	xz = Nx;

	yz = Ny;

	Nx = (double) (xw * ct - yw * st);

	Ny = (double) (xw * st + yw * ct);

	xw = Nx;

	yw = Ny;

  }

  /**

   *  Scale.

   *  @param  f   factor to scale with.

   */

  public void scale(double f) {

	xx *= f;

	yx *= f;

	zx *= f;

	wx *= f;

	xy *= f;

	yy *= f;

	zy *= f;

	wy *= f;

	xz *= f;

	yz *= f;

	zz *= f;

	wz *= f;

  }

  /**

   *  Scale different in x,y,z.

   *  @param  fx   scaling factor in x

   *  @param  fy   scaling factor in y

   *  @param  fz   scaling factor in z

   */

  public void scale(double fx, double fy, double fz) {

	xx *= fx;

	yx *= fx;

	zx *= fx;

	wx *= fx;

	xy *= fy;

	yy *= fy;

	zy *= fy;

	wy *= fy;

	xz *= fz;

	yz *= fz;

	zz *= fz;

	wz *= fz;

  }

  private static final double MIN_INT = (double)Short.MIN_VALUE;

  private static final double MAX_INT = (double)Short.MAX_VALUE;

  /**

   *  Transform some points.

   *  @param  v       points to transform

   *  @param  tx      transformed points x coord

   *  @param  ty      transformed points y coord

   *  @param  tz      transformed points z coord

   *  @param  npoints nr of points to transform

   */

  public void transform(Point3D v[], int tx[], int ty[], int tz[], int npoints) {

	Point3D tmp;

	for (int i = npoints; --i >= 0;) {

	  tmp = mult(v[i]);

	  if (tmp.x < MIN_INT) {

	tmp.x = MIN_INT;

	  }

	  else if (tmp.x > MAX_INT) {

	tmp.x = MAX_INT;

	  }

	  if (tmp.y < MIN_INT) {

	tmp.y = MIN_INT;

	  }

	  else if (tmp.y > MAX_INT) {

	tmp.y = MAX_INT;

	  }

	  if (tmp.z < MIN_INT) {

	tmp.z = MIN_INT;

	  }

	  else if (tmp.z > MAX_INT) {

	tmp.z = MAX_INT;

	  }

	  tx[i] = (int) tmp.x;

	  ty[i] = (int) tmp.y;

	  tz[i] = (int) tmp.z;

	}

  }

  /**

   *  Output

   *  @return String representing this.

   */

  public String toString() {

	return new String(new StringBuffer().append("{{").

	  append(xx).append(",").append(xy).append(",").append(xz).append(",").append(xw).

	  append("},{").

	  append(yx).append(",").append(yy).append(",").append(yz).append(",").append(yw).

	  append("},{").

	  append(zx).append(",").append(zy).append(",").append(zz).append(",").append(zw).

	  append("},{").

	  append(wx).append(",").append(wy).append(",").append(wz).append(",").append(ww).

	  append("}}"));

  }

}

/*

 *

 * 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