/branches/v10/libraries/libDwg/src/com/iver/cit/jdwglib/dwg/DwgFile.java - Diff - Application: gvSIG desktop - gvSIG

Revision 23114 branches/v10/libraries/libDwg/src/com/iver/cit/jdwglib/dwg/DwgFile.java

     /* jdwglib. Java Library for reading Dwg files.
+     *
+     *
      * Author: Jose Morell Rama (jose.morell@gmail.com).
      * Port from the Pythoncad Dwg library by Art Haas.
+     *
-...
      * For more information, contact:
+     *
      * Jose Morell (jose.morell@gmail.com)
+     *
+     *
      * or
+     *
      * IVER TI S.A.
-...
     import java.util.Iterator;
     import java.util.List;
     import java.util.Map;
     import java.util.Vector;
     import org.apache.log4j.Logger;
-...
      * Reading methods are useful for reading DWG files, and handling methods like
      * calculateDwgPolylines() are useful for handling more complex
      * objects in the DWG file
+     *
+     *
      * @author jmorell
      * @author azabala
      */
-...
     		acadVersions.put("AC402b", "Autocad pre-2004b");
     		acadVersions.put("AC1018", "Autocad R2004, R2005, R2006");
     		acadVersions.put("AC1021", "Autocad R2007");
+    	}
     	private static Logger logger = Logger.getLogger(DwgFile.class
     			.getName());
     	/**
-...
     	 * DWG version of the file (AC1013, AC1018, etc.)
     	 * */
     	private String dwgVersion;
     	/**
     	 * Offsets to the DWG sections
     	 */
-...
     	 * Header vars readed from the HEADER section of the DWG file
     	 * */
     	private Map headerVars;
     	/**
     	 * This list contains what in OpenDWG specification is called
     	 * the object map ( a collection of entries where each entry contains
     	 * the seek of each object, and its size)
     	 * */
     	private ArrayList dwgObjectOffsets;
     	/**
     	 * For each entry in dwgObjectOffsets, we have an instance of
     	 * DwgObject in the dwgObjects collection
+    	 *
+    	 *
     	 * */
     	private List dwgObjects;
     	private HashMap handle_objects;
     	private ArrayList dwgClasses;
     	/**
     	 * hash map that indexes all DwgLayer objects
     	 * by its handle property
     	 * */
     	private HashMap layerTable;
     	private HashMap layerTable;
     	/**
     	 * Specific reader of the DWG file version (12, 13, 14, 2000, etc., each
     	 * version will have an specific reader)
-...
     	 * Memory mapped byte buffer of the whole DWG file
     	 * */
     	private ByteBuffer bb;
     	/*
     	 * Optimizaciones para evitar leer el fichero completo en cada
     	 * pasada.
-...
     	/**
     	 * Contains all INSERT entities of the dwg file
     	 * (these entities must be processed in a second pass)
+    	 *
+    	 *
     	 * */
     	private List insertList;
     	private List blockList;
     	/**
     	 * Constructor.
     	 * @param fileName an absolute path to the DWG file
     	 */
     	public DwgFile(String fileName) {
     		this.fileName = fileName;
     		dwgSectionOffsets = new ArrayList();
     		dwgObjectOffsets = new ArrayList();
     		headerVars = new HashMap();
     		dwgClasses = new ArrayList();
     		dwgObjects = new ArrayList();
     		handle_objects = new HashMap();
     		layerTable = new HashMap();
     		dwgPolylines = new ArrayList();
     		insertList = new ArrayList();
     		blockList = new ArrayList();
+    	}
     	public String getDwgVersion() {
     		return dwgVersion;
+    	}
     	/**
     	 * Reads a DWG file and put its objects in the dwgObjects Vector
     	 * This method is version independent
+    	 *
+    	 *
     	 * @throws IOException If the file location is wrong
     	 */
     	public void read() throws IOException,
     	public void read() throws IOException,
     				DwgVersionNotSupportedException
+    	{
     		setDwgVersion();
     		if (dwgVersion.equalsIgnoreCase("Autocad R2000, R2000i, R2002")) {
     			dwgReader = new DwgFileV15Reader();
     		}else if (dwgVersion.equalsIgnoreCase("Autocad pre-R14")||
     		}else if (dwgVersion.equalsIgnoreCase("Autocad pre-R14")||
     				dwgVersion.equalsIgnoreCase("Autocad R14") ||
     				dwgVersion.equalsIgnoreCase("Autocad R13")) {
     			dwgReader = new DwgFileV14Reader();
     		}else if (dwgVersion.equalsIgnoreCase("Autocad R2004, R2005, R2006")){
     			dwgReader = new DwgFileVR2004Reader();
     		} else if (dwgVersion.equalsIgnoreCase("Autocad R12")||
     		} else if (dwgVersion.equalsIgnoreCase("Autocad R12")||
     				dwgVersion.equalsIgnoreCase("Autocad pre-R13 a") ||
     				dwgVersion.equalsIgnoreCase("Autocad pre-R13 b")) {
     			boolean isR13 = true;
     			if(dwgVersion.equalsIgnoreCase("Autocad R12"))
     					isR13 = false;
     			dwgReader = new DwgFileV12Reader(isR13);
     		}else {
     			DwgVersionNotSupportedException exception =
     			DwgVersionNotSupportedException exception =
     				new DwgVersionNotSupportedException("Version de DWG no soportada");
     			exception.setDwgVersion(dwgVersion);
     			throw exception;
-...
     			throw new IOException("Error leyendo dwg");
+    		}
+    	}
     	private void setDwgVersion() throws IOException {
     		File file = new File(fileName);
     		FileInputStream fileInputStream = new FileInputStream(file);
     		FileChannel fileChannel = fileInputStream.getChannel();
     		long channelSize = fileChannel.size();
     		bb = fileChannel.map(FileChannel.MapMode.READ_ONLY, 0, channelSize);
     		byte[] versionBytes = {bb.get(0),
     								bb.get(1),
     		byte[] versionBytes = {bb.get(0),
     								bb.get(1),
     								bb.get(2),
     								bb.get(3),
     								bb.get(4),
     								bb.get(4),
     								bb.get(5)};
     		ByteBuffer versionByteBuffer = ByteBuffer.wrap(versionBytes);
     		String[] bs = new String[versionByteBuffer.capacity()];
-...
     		String version = (String) acadVersions.get(versionString);
     		if(version == null)
     			version = "Unknown Dwg format";
     		this.dwgVersion = version;
     		this.dwgVersion = version;
+    	}
     	public void setHeader(String key, Object value){
     		headerVars.put(key, value);
+    	}
     	public Object getHeader(String key){
     		return headerVars.get(key);
+    	}
     	/*
     	 * A DwgLayer is a DWG drawing entity, so all DwgLayer objects are
     	 * saved in dwgObjects collection.
-...
+    	 *
     	 */
     	protected void addDwgLayer(DwgLayer dwgLayer){
     		layerTable.put(new Integer(dwgLayer.getHandle().getOffset()),
     		layerTable.put(new Integer(dwgLayer.getHandle().getOffset()),
     				dwgLayer);
+    	}
     	private void printInfoOfAObject (DwgObject entity){
     		logger.info("index = "+entity.getIndex() + " entity.type = " + entity.type + " entityClassName = "+ entity.getClass().getName());
     		logger.info("handleCode = "+entity.getHandle().getCode());
-...
     				logger.info (" reactorHandle = "+hr.getOffset());
+    			}
+    		}
+    	}
     	public DwgLayer getDwgLayer(DwgObject entity){
     		DwgHandleReference handle = entity.getLayerHandle();
-...
     		int	handleCode = handle.getCode();
     		int	entityLayerHandle = entity.getLayerHandle().getOffset();
     		int layerHandle = -1;
     		int entityRecord;
     		DwgObject object;
     		/*
     		 * OpenDWG spec, v3, page 11. HANDLE REFERENCES
+    		 *
+    		 *
     		 * A handle is formed by this fields:
     		 * a) CODE (4 bits)
     		 * b) COUNTER (4 bits)
     		 * c) OFFSET of the object (handle itself).
+    		 *
+    		 *
     		 * CODE could take these values:
     		 * 1) 0x2, 0x3, 0x4, 0x5 -> offset is the handle of the layer
     		 * 2) 0x6 -> offset is the next object handle
     		 * 3) 0x8 -> offset is the previous object handle
     		 * 4) 0xA -> result is reference handle plus offset
      		 * 5) 0xC -> result is reference handle minus offset
+    		 *
+    		 *
     		 * */
     		// FIXME: Esto no esta terminado. Falta considerar los codigo
     		// 0x2, 0x3, 0x6, 0xA que no han aparecido en los archivos de prueba.
     		switch(handleCode){
-...
     		default:
     //			System.out.println ("DwgFile.getDwgLayer: handleCode "+handleCode+" no implementado. entityLayerHandle="+entityLayerHandle);
+    		}
     		if(layerHandle != -1){
     			Iterator lyrIterator = layerTable.values().iterator();
     			while(lyrIterator.hasNext()){
-...
     //		printInfoOfAObject(entity);
     		return null;
+    	}
     	public DwgObject getDwgSuperEntity(DwgObject entity) {
     		if(entity.hasSubEntityHandle()){
     			int handleCode = entity.subEntityHandle.getCode();
     			int offset = entity.subEntityHandle.getOffset();
     			int handle = -1;
     			DwgObject object;
     			switch(handleCode){
-...
+    		}
     		return null;
+    	}
     	public String getLayerName(DwgObject entity) {
     	public String getLayerName(DwgObject entity) {
     		DwgLayer dwgLayer = getDwgLayer(entity);
     		if(dwgLayer == null){
     			return "";
-...
     			return dwgLayer.getName();
+    		}
+    	}
     	/**
          * Returns the color of the layer of a DWG object
+    	 *
          * Returns the color of the layer of a DWG object
+    	 *
          * @param entity DWG object which we want to know its layer color
     	 * @return int Layer color of the DWG object in the Autocad color code
     	 */
-...
     		/*
     		 * In Dwg 12 format, all vertices of a polyline are between polyline entity
     		 * and endsec entity. Also, polylines dont save any handle of their vertices (first and last).
+    		 *
+    		 *
     		 * After Dwg 12 version, we have the opposite case: polylines have handles/pointers to their
     		 * first and last vertices.
+    		 *
+    		 *
     		 * If dwg file is not V12, we must look for all polyline vertices (and we must to wait until
     		 * all entities are readed).
     		 * If dwg file is V12, all polylines already have their vertices.
-...
     				DwgObject pol = (DwgObject)dwgPolylines.get(i);
     				if (pol instanceof IDwgPolyline) {
     					((IDwgPolyline)pol).calculateGisModel(this);
     				}//if
     				}//if
     			}//for
+    		}
+    	}
         /**
          * Configure the geometry of the polylines in a DWG file from the vertex list in
          * this DWG file. This geometry is given by an array of Points
-...
          * parameter called bulge associated with the points of the polyline.
          */
     	//TODO Refactorizar para que solo se aplique a las Polilineas
     //	public void calculateCadModelDwgPolylines() {
     //		for (int i=0;i<dwgObjects.size();i++) {
     //			DwgObject pol = (DwgObject)dwgObjects.get(i);
-...
     //			}
     //		}
     //	}
     	/*
     	 * TODO Revisar los bloques que son XREF
     	 * */
     	public void blockManagement2(){
     		Iterator it = null;
     		//dwg v12 blocks already has their entities added
     		//for the rest of versions, we add block entities to their owner block
     		if(! (dwgReader instanceof DwgFileV12Reader)){
-...
+    				}
     			}//while
     		}//if dwgfilev12
     		//after that, we process the INSERTs
     		it = insertList.iterator();
     		while(it.hasNext()){
-...
     			double rot = insert.getRotation();
     			int blockHandle = insert.getBlockHeaderHandle().getOffset();
     			manageInsert2(point, scale,
     					rot, blockHandle,
     					rot, blockHandle,
     					dwgObjects, handle_objects);
+    		}
+    		}
+    }
     	public void manageInsert2(Point2D insPoint, double[] scale,
     			double rot, int bHandle,
     			List dwgObjectsWithoutBlocks,
     			double rot, int bHandle,
     			List dwgObjectsWithoutBlocks,
     			Map handleObjectsWithoutBlocks) {
     		DwgObject object = (DwgObject) handle_objects.get(new Integer(bHandle));
     		if(object == null){
     			logger.error("No hemos encontrado el BlockHeader cuyo handle es "+bHandle);
-...
     			logger.error("handle incorrecto." + object.getClass().getName() + " no es un blockheader");
     			return;
+    		}
     		DwgBlockHeader blockHeader = (DwgBlockHeader)object;
     		double[] bPoint = blockHeader.getBasePoint();
     		String bname = blockHeader.getName();
     		if (bname.startsWith("*"))
     		if (bname.startsWith("*"))
     			return;
     		//TODO Cambiar por List
     		Vector entities = blockHeader.getObjects();
     		//TODO Cambiar por List. Done.
     		List entities = blockHeader.getObjects();
     		if(entities.size() == 0){
     			logger.warn("El bloque "+blockHeader.getName()+" no tiene ninguna entidad");
+    		}
     		Iterator blkEntIt = entities.iterator();
     		while(blkEntIt.hasNext()){
     			DwgObject obj = (DwgObject) blkEntIt.next();
     			 manageBlockEntity(obj, bPoint,
     			 		  insPoint, scale,
     			 manageBlockEntity(obj, bPoint,
     			 		  insPoint, scale,
     			 		  rot, dwgObjectsWithoutBlocks,
     			 		  handleObjectsWithoutBlocks);
     			 		  handleObjectsWithoutBlocks);
     		}//while
+    	}
     	public int getIndexOf(DwgObject dwgObject){
     		return dwgObjects.indexOf(dwgObject);
     		return dwgObjects.indexOf(dwgObject);
+    	}
         /**
          * Changes the location of an object extracted from a block. This location will be
          * obtained through the insertion parameters from the block and the corresponding
-...
          * @param dwgObjectsWithoutBlocks, a object list with the elements extracted from
          * the blocks.
          */
     	private void manageBlockEntity(DwgObject entity,
     									double[] bPoint,
     									Point2D insPoint,
     									double[] scale,
     									double rot,
     	private void manageBlockEntity(DwgObject entity,
     									double[] bPoint,
     									Point2D insPoint,
     									double[] scale,
     									double rot,
     									List dwgObjectsWithoutBlocks,
     									Map handleObjectsWithoutBlocks) {
     		if(entity instanceof IDwgBlockMember){
     			IDwgBlockMember blockMember = (IDwgBlockMember)entity;
     			blockMember.transform2Block(bPoint, insPoint, scale, rot,
     			blockMember.transform2Block(bPoint, insPoint, scale, rot,
     					dwgObjectsWithoutBlocks,
     					handleObjectsWithoutBlocks,this);
+    		}
+    	}
     	/**
     	 * Add a DWG section offset to the dwgSectionOffsets vector
+    	 *
+    	 *
     	 * @param key Define the DWG section
     	 * @param seek Offset of the section
     	 * @param size Size of the section
-...
     		DwgSectionOffset dso = new DwgSectionOffset(key, seek, size);
     		dwgSectionOffsets.add(dso);
+    	}
     	/**
          * Returns the offset of DWG section given by its key
+    	 *
          * Returns the offset of DWG section given by its key
+    	 *
          * @param key Define the DWG section
     	 * @return int Offset of the section in the DWG file
     	 */
-...
+    		}
     		return offset;
+    	}
     	/**
     	 * Add a DWG object offset to the dwgObjectOffsets vector
+    	 *
+    	 *
     	 * @param handle Object handle
     	 * @param offset Offset of the object data in the DWG file
     	 */
-...
     		DwgObjectOffset doo = new DwgObjectOffset(handle, offset);
     		dwgObjectOffsets.add(doo);
+    	}
     	/**
+    	 *
+    	 *
     	 * Add a DWG object to the dwgObject vector
+    	 *
+    	 *
     	 * @param dwgObject DWG object
     	 */
     	public void addDwgObject(DwgObject dwgObject){
     		//TODO Ver si puedo inicializar las listas especificas
     		//(IDwgPolyline, etc) aqu�
     		//(IDwgPolyline, etc) aqu�
     		dwgObjects.add(dwgObject);
     		/*
     		 * TODO Quitar todos estos if-then y sustituirlos por un metodo callback
+    		 *
+    		 *
+    		 *
+    		 *
     		 * (dwgObject.init(this), y que cada objeto haga lo que tenga que hacer
     		 * */
     		if(dwgObject instanceof DwgLayer){
     			this.addDwgLayer((DwgLayer) dwgObject);
+    		}
     		//Probamos a no aplicar las extrusiones
     		if(dwgObject instanceof IDwgExtrusionable){
     			((IDwgExtrusionable)dwgObject).applyExtrussion();
+    		}
     		if(dwgObject instanceof IDwgPolyline){
     			dwgPolylines.add(dwgObject);
+    		}
-...
     		if(dwgObject instanceof DwgInsert){
     			insertList.add(dwgObject);
+    		}
     		if(dwgObject instanceof DwgBlockHeader){
     			blockList.add(dwgObject);
+    		}
     		handle_objects.put(new Integer(dwgObject.getHandle().getOffset()), dwgObject);
+    	}
     	/**
     	 * Returns dwgObjects from its insertion order (position
     	 * in the dwg file)
+    	 *
+    	 *
     	 * @param index order in the dwg file
     	 * @return position
     	 * */
     	public DwgObject getDwgObject(int index){
     		return (DwgObject) dwgObjects.get(index);
+    	}
     	public DwgObject getDwgObjectFromHandle(int handle){
     		return (DwgObject) handle_objects.get(new Integer(handle));
+    	}
     	/**
     	 * Add a DWG class to the dwgClasses vector
+    	 *
+    	 *
     	 * @param dwgClass DWG class
     	 */
     	public void addDwgClass(DwgClass dwgClass){
     		dwgClasses.add(dwgClass);
+    	}
     	/**
     	 * Add a DWG class to the dwgClasses vector
+    	 *
+    	 *
     	 * @param dwgClass DWG class
     	 */
     	public void addDwgClass(DwgClass2004 dwgClass){
     		dwgClasses.add(dwgClass);
+    	}
     	public void printClasses(){
     		logger.info("#### CLASSES ####");
     		for(int i = 0; i < dwgClasses.size(); i++){
-...
+    		}
     		logger.info("#############");
+    	}
     	public List getDwgClasses(){
     		return dwgClasses;
+    	}
         /**
          * @return Returns the dwgObjectOffsets.
          */

Also available in: Unified diff