| gvSIG desktop 1

 *

 * $Id$

 * $Log$

 * Revision 1.3  2007-03-20 19:57:08  azabala

 * source code cleaning

 *

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

 * Changes to adapt dwg 12 to general architecture

 *

 * Revision 1.1  2007/03/01 19:58:53  azabala

 * refactor of pface and mesh names

 *

 * Revision 1.2  2007/02/07 12:44:27  fdiaz

 * A?adido o modificado el metodo clone para que el DwgObject se encargue de las propiedades comunes a todos los objetos.

 * A?adido el metodo fill.

 *

 * Revision 1.1  2007/02/05 07:03:22  azabala

 * *** empty log message ***

 *

 *

 */

import java.awt.geom.Point2D;

import java.util.Map;

import com.iver.cit.gvsig.fmap.core.FGeometryCollection;

import com.iver.cit.gvsig.fmap.core.FPolygon3D;

import com.iver.cit.gvsig.fmap.core.IGeometry;

import com.iver.cit.gvsig.fmap.core.ShapeFactory;

import com.iver.cit.jdwglib.dwg.IDwgBlockMember;

import com.iver.cit.jdwglib.util.FMapUtil;

 */

/*

 * azabala DXF 12 spec says: "If the Vertex defines a face of the mesh, its

 * Vertex flags (70) group has the 128 bit set but not the 64 bit. The 10, 20,

 * and 30 (location) groups of the face entity are irrelevant and are always

 * written as zero in a DXF file.

 * 

 * The vertex indexes that define the mesh are given by 71, 72, 73, and 74

 * groups, the values of which are integers specifying one of the previously

 * defined vertices by index.

 * 

 * If the index is negative, the edge that begins with that vertex is invisible.

 * 

 * The first zero vertex marks the end of the vertices of the face.

 * 

 * Since the 71 through 74 groups are optional fields with default values of

 * zero, they are present in DXF only if nonzero."

 * 

 * But DWG 12 spec doesnt say anything about 71,72,73 and 74 fields for VERTEX.

 */

	implements IDwgPolyline, IDwg2FMap, IDwgBlockMember{

	public static final int NUM_VERTEX_OF_FACE = 4;

	 * number of vertices in the mesh (as it is readed from the dwg file... very

	 * often is wrong)

	 */

	 * number of faces of the mesh (as it is readed from the dwg file... very

	 * often is wrong)

	 */

	/**

	 * Collection of all the vertices of the polyface mesh

	 */

	/**

	 * Collection of all the faces of the polyface mesh, whose vertices are in

	 * vertices List.

	 */

	private List faces;

	 */

		faces = new ArrayList();

		myObj.setVertices(this.vertices);

		myObj.setFaces(this.faces);

	public void setFaces(List faces) {

		this.faces = faces;

	}

	public List getFaces(){

		return this.faces;

	}

	// In DWG 13, 14 and 2000 version, a Polyface mesh has

    // handles references to its vertices.

	// In DWG 12 vertices are after the entity

	 if(firstVertexHandle != null && lastVertexHandle != null){

		 	DwgObject first = dwgFile.getDwgObjectFromHandle(firstVertexHandle.getOffset());

			DwgObject last = dwgFile.getDwgObjectFromHandle(lastVertexHandle.getOffset());

			if(first == null || last == null){

				System.out.println("DwgPFacePolyline con vertices inicial o final a null");

				return;

			if(!(first instanceof IDwgVertex)){

				System.out.println("El primer vertice de PFacePolyline es "+

								first.getClass().getName());

				return;

			if(!(last instanceof IDwgVertex)){

				System.out.println("El ultimo vertice de PFacePolyline es "+

						last.getClass().getName());

				return;

			}

			 int firstObjIdx = dwgFile.getIndexOf(first);

			 int lastObjIdx =  dwgFile.getIndexOf(last);

			 if(firstObjIdx == -1 || lastObjIdx == -1){

				 System.out.println("Calculate GIS Model: Problemas en "+

						 "la localizacion de vertices: 1?="

						 	+firstObjIdx+

						 	",Ultimo="+lastObjIdx);

				 return;

			 }

			 for(int i = firstObjIdx; i <= lastObjIdx; i++){

				 DwgObject obj = dwgFile.getDwgObject(i);

				 if(obj instanceof IDwgVertex){

				 	this.addVertex((IDwgVertex)obj);

				 }else if(obj instanceof DwgSeqend){

				 	// TODO SEE IF BREAK THE ITERATION

				 	break;

				 }else{

				 	System.out.println("Encontrado "+obj.getClass().getName()+" en la lista de vertices de Polyline3D");

				 }

			 }// for

			// TODO: No se debe mandar nunca una polil?nea sin puntos, si

			// esto

		}

	public IGeometry toFMapGeometry(boolean is3DFile) {

		FGeometryCollection solution = null;

		IGeometry[] geometries = null;

		if(vertices != null && faces != null){

			if(vertices.size() == 0 || faces.size() == 0){

				return solution;

			}

			ArrayList geomList = new ArrayList();

			int numFaces = faces.size();

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

				DwgVertexPFaceFace face = (DwgVertexPFaceFace) faces.get(i);

				int[] verticesId = face.getVerticesidx();

				ArrayList pts = new ArrayList();

				boolean lastWasInvisible = true;

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

					if(verticesId[j] > 0){

	                    if(lastWasInvisible){

	                        pts.clear();

	                        lastWasInvisible = false;

	                    }

	                    // the index is 1-based

	                    try{

	                    pts.add(vertices.get(verticesId[j] -1));

	                    }catch(Throwable t){

	                    	t.printStackTrace();

	                    }

	                } else if(verticesId[j] < 0 && !lastWasInvisible){

	                    lastWasInvisible = true;

	                    pts.add(vertices.get( (verticesId[j] * -1) -1));

	                }	

				}// for j

				FPolygon3D polygon = FMapUtil.ptsTo3DPolygon(pts);

				IGeometry geom = ShapeFactory.createGeometry(polygon);

				geomList.add(geom);

// if(!lastWasInvisible){

// if(vertex[nrV] < 0){

// line.addPoint(knot[-vertex[nrV] - 1]);

// } else{

// line.addPoint(knot[vertex[nrV] - 1]);

// }

// set.addDrawable(line);

// }

			}// for i

			geometries = new IGeometry[geomList.size()];

			geomList.toArray(geometries);

			solution = new FGeometryCollection(geometries);

		}

		return solution;

	}

	/*

	 * (non-Javadoc)

	 * 

	 * @see com.iver.cit.jdwglib.dwg.IDwg2FMap#toFMapString(boolean)

	 */

		if(is3DFile)

			return "FPolyline3D";

		else

			return "FPolyline2D";

	public String toString(){

		return "PFacePolyline";

	}

		// here we save the vertex (not the coordinate) because

		// this Polyline could have two kind of vertex (pface and pfaceface)

		if(vertex instanceof DwgVertexPFaceFace)

			faces.add(vertex);

		else 

			vertices.add(vertex);

	public void dump(){

		System.out.println("<PFacePolyline vertexCount="+vertexCount+" faceCount"+faceCount+">");

		int numRealVertex = 1;

		for(int i = 0; i < vertices.size(); i++){

			IDwgVertex vertex = (IDwgVertex) vertices.get(i);

			double[] point = vertex.getPoint();

			System.out.println("<Vertex idx="+numRealVertex+" class="+vertex.getClass().getName()+" x="+point[0]+" y="+point[1]+" z="+point[2]+" >");

			numRealVertex++;

		}

		for(int i = 0; i < faces.size(); i++){

			IDwgVertex vertex = (IDwgVertex) faces.get(i);

			if(vertex instanceof DwgVertexPFaceFace){

				int[] point = ((DwgVertexPFaceFace)vertex).getVerticesidx();

				System.out.println("<Vertex class="+vertex.getClass().getName()+" 1="+point[0]+" 2="+point[1]+" 3="+point[2]+" 4="+ point[3]+">");

			}

		}

		System.out.println("</PFacePolyline>");

	}

	public void transform2Block(double[] bPoint, Point2D insPoint, double[] scale, double rot, List dwgObjectsWithoutBlocks, Map handle_objectsWithoutBlocks, DwgFile callBack) {

		DwgPFacePolyline transformedEntity = null;

		List vertices = this.getVertices();

		if (vertices != null) {

			if(vertices.size() == 0)

				return;

		    List transformedVertices = new ArrayList();

			for (int i=0;i < vertices.size();i++) {

				double[] pointAux = null;

				IDwgVertex vertex = (IDwgVertex) vertices.get(i);

			    if(!(vertex instanceof DwgVertexPFaceFace)){

			    	// DwgVertexPFaceFace hasnt coordinates, instead

			    	// it has indices in the vertex array

					double[] point = vertex.getPoint();

				    pointAux = new double[]{point[0] - bPoint[0],

				    		point[1] - bPoint[1], point[2] - bPoint[2]};

					double laX = insPoint.getX() + ((pointAux[0] * scale[0])*Math.cos(rot) + (pointAux[1]*scale[1])*(-1)*Math.sin(rot));

					double laY = insPoint.getY() + ((pointAux[0]*scale[0])*Math.sin(rot) + (pointAux[1]*scale[1])*Math.cos(rot));

					double laZ = pointAux[2];

					vertex.setPoint(new double[]{laX, laY, laZ});

					transformedVertices.add(vertex);	

				}

			}// for

			transformedEntity = (DwgPFacePolyline)this.clone();

			fill(transformedEntity);

			dwgObjectsWithoutBlocks.add(transformedEntity);

			handle_objectsWithoutBlocks.put(new Integer(transformedEntity.getHandle().getOffset()), transformedEntity);

		}// if

	}