Application: gvSIG desktop

/* DielmoOpenLiDAR

 *

 * Copyright (C) 2008 DIELMO 3D S.L. (DIELMO) and Infrastructures  

 * and Transports Department of the Valencian Government (CIT)

 * 

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License

 * as published by the Free Software Foundation; either version 2

 * of the License, or (at your option) any later version.

 * 

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 * 

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, 

 * MA  02110-1301, USA.

 *

 * For more information, contact:

 *

 * DIELMO 3D S.L.

 * Plaza Vicente Andr?s Estell?s 1 Bajo E

 * 46950 Xirivella, Valencia

 * SPAIN

 *   

 * +34 963137212

 * dielmo@dielmo.com

 * www.dielmo.com

 * 

 * or

 * 

 * Generalitat Valenciana

 * Conselleria d'Infraestructures i Transport

 * Av. Blasco Ib??ez, 50

 * 46010 VALENCIA

 * SPAIN

 *

 * +34 963862235

 * gvsig@gva.es

 * www.gvsig.gva.es

 */

/*

 * AUTHORS (In addition to DIELMO and CIT):

 *  

 */

package com.dielmo.gvsig.lidar.Strategies;

import com.dielmo.gvsig.lidar.drivers.LiDARDriver;

import com.dielmo.gvsig.lidar.extensions.LiDAR_Mapping;

import com.iver.cit.gvsig.fmap.layers.CancelationException;

import com.iver.cit.gvsig.fmap.layers.FLyrVect;

import com.iver.cit.gvsig.fmap.layers.LayerCollectionEvent;

import com.iver.cit.gvsig.fmap.layers.LayerCollectionListener;

import com.iver.cit.gvsig.fmap.layers.LayerPositionEvent;

public class LidarWatcher implements LayerCollectionListener {

	private static LidarWatcher theInstance = null;

	public static LidarWatcher getInstance() {

		if (theInstance == null)

			theInstance = new LidarWatcher();

		return theInstance;

	}

	LidarWatcher() {

	}

	public void layerAdded(LayerCollectionEvent e) {

		if (LiDARDriver.isLidarLayer(e.getAffectedLayer())){

			FLyrVect lyrVect = (FLyrVect) e.getAffectedLayer();		

			if (lyrVect.getStrategy() != null)

				if (!(lyrVect.getStrategy() instanceof LiDARStrategy)) {

					LiDAR_Mapping map = new LiDAR_Mapping();

					int grosor = map.getSizePixel();

					LiDARStrategy lidarStrategy = new LiDARStrategy(lyrVect,grosor);

					lyrVect.setStrategy(lidarStrategy);

				}

		}

	}

	public void layerAdding(LayerCollectionEvent e) throws CancelationException {

		// TODO Auto-generated method stub

	}

	public void layerMoved(LayerPositionEvent e) {

		// TODO Auto-generated method stub

	}

	public void layerMoving(LayerPositionEvent e) throws CancelationException {

		// TODO Auto-generated method stub

	}

	public void layerRemoved(LayerCollectionEvent e) {

		// TODO Auto-generated method stub

	}

	public void layerRemoving(LayerCollectionEvent e)

			throws CancelationException {

		// TODO Auto-generated method stub

	}

	public void visibilityChanged(LayerCollectionEvent e)

			throws CancelationException {

		// TODO Auto-generated method stub

	}

}

/* DielmoOpenLiDAR

 *

 * Copyright (C) 2008 DIELMO 3D S.L. (DIELMO) and Infrastructures  

 * and Transports Department of the Valencian Government (CIT)

 * 

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License

 * as published by the Free Software Foundation; either version 2

 * of the License, or (at your option) any later version.

 * 

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 * 

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, 

 * MA  02110-1301, USA.

 *

 * For more information, contact:

 *

 * DIELMO 3D S.L.

 * Plaza Vicente Andr?s Estell?s 1 Bajo E

 * 46950 Xirivella, Valencia

 * SPAIN

 *   

 * +34 963137212

 * dielmo@dielmo.com

 * www.dielmo.com

 * 

 * or

 * 

 * Generalitat Valenciana

 * Conselleria d'Infraestructures i Transport

 * Av. Blasco Ib??ez, 50

 * 46010 VALENCIA

 * SPAIN

 *

 * +34 963862235

 * gvsig@gva.es

 * www.gvsig.gva.es

 */

/*

 * AUTHORS (In addition to DIELMO and CIT):

 *  

 */

package com.dielmo.gvsig.lidar.Strategies;

import java.awt.Graphics2D;

import java.awt.geom.Point2D;

import java.awt.geom.Rectangle2D;

import java.awt.image.BufferedImage;

import org.cresques.cts.ICoordTrans;

import com.iver.andami.PluginServices;

import com.iver.cit.gvsig.fmap.DriverException;

import com.iver.cit.gvsig.fmap.ViewPort;

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

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

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

import com.iver.cit.gvsig.fmap.drivers.DriverAttributes;

import com.iver.cit.gvsig.fmap.drivers.DriverIOException;

import com.iver.cit.gvsig.fmap.layers.FBitSet;

import com.iver.cit.gvsig.fmap.layers.FLayer;

import com.iver.cit.gvsig.fmap.layers.ReadableVectorial;

import com.iver.cit.gvsig.fmap.layers.SelectableDataSource;

import com.iver.cit.gvsig.fmap.layers.layerOperations.AlphanumericData;

import com.iver.cit.gvsig.fmap.layers.layerOperations.ClassifiableVectorial;

import com.iver.cit.gvsig.fmap.layers.layerOperations.SingleLayer;

import com.iver.cit.gvsig.fmap.operations.strategies.DefaultStrategy;

import com.iver.cit.gvsig.fmap.operations.strategies.FeatureVisitor;

import com.iver.cit.gvsig.fmap.operations.strategies.VisitException;

import com.iver.cit.gvsig.fmap.rendering.VectorialLegend;

import com.iver.cit.gvsig.project.documents.view.gui.View;

import com.iver.utiles.swing.threads.Cancellable;

import com.iver.utiles.swing.threads.CancellableMonitorable;

/**

 * Esta clase se encargar? de dibujar las capas LiDAR

 * 

 * @author Jos? Carlos Garcia

 */

public class LiDARStrategy extends DefaultStrategy {

	int maxGrosor;

	ViewPort viewportCapa;

	/**

	 * Crea un nuevo LiDARStrategy.

	 * 

	 * @param layer

	 */

	public LiDARStrategy(FLayer layer, int grosor) {

		super(layer);

		viewportCapa = ((View) PluginServices.getMDIManager().getActiveWindow()).getMapControl().getViewPort();

		maxGrosor=grosor;

	}

	/**

	 * Recorre las features de la capa vectorial invocando el m?todo visit del

	 * visitador que se pasa como par?metro, que es el que realizar? la

	 * operaci?n relacionada con la geometry.

	 * 

	 * @param visitor

	 * @param cancel

	 * @throws DriverException

	 * @throws VisitException

	 */

	public void process(FeatureVisitor visitor, CancellableMonitorable cancel) throws DriverException, VisitException {

		try {

			FLayer capa = getCapa();

			if (visitor.start(capa)) {

				ReadableVectorial va = ((SingleLayer) capa).getSource();

				ICoordTrans ct = getCapa().getCoordTrans();

				va.start();

				if(va.getFullExtent().intersects(viewportCapa.getAdjustedExtent())){

					for (int i = 0; i < va.getShapeCount(); i++) {

						if(cancel != null){

							cancel.reportStep();

						}

						if(verifyCancelation(cancel, va, visitor))

							return;

					    IGeometry geom = va.getShape(i);

					    if (ct != null) {

							geom.reProject(ct);

						}

						visitor.visit(geom, i);

					}	

				}

				va.stop();

//				logger.info("visitor.stop()");

				visitor.stop(capa);

			}

		} catch (DriverIOException e) {

			throw new DriverException(e);

		}

	}

	/**

	 * Dibuja la capa vectorial asociada al Strategy en la imagen que se pasa

	 * como par?metro.

	 *

	 * @param image

	 * @param g

	 * @param viewPort

	 * @param cancel

	 *

	 * @throws DriverException

	 */

	public void draw(BufferedImage image, Graphics2D g, ViewPort viewPort,

			Cancellable cancel) throws DriverException {

		try {

			ReadableVectorial rvLiDAR = ((SingleLayer) getCapa()).getSource();

			ICoordTrans ct = getCapa().getCoordTrans();

			// logger.info("adapter.start()");

			rvLiDAR.start();

			// logger.info("getCapa().getRecordset().start()");

			SelectableDataSource dsLidar = ((AlphanumericData) getCapa())

					.getRecordset();

			if (dsLidar != null)

				dsLidar.start();

			int numRowsLidar;

			Rectangle2D extent = viewPort.getAdjustedExtent();

			Rectangle2D fullExtent = getCapa().getFullExtent();

			if (!extent.intersects(fullExtent))

				return;

			// ati = viewPort.getAffineTransform();

			numRowsLidar = rvLiDAR.getShapeCount();

			// TODO: A revisar si es o no conveniente este sistema

			// de comunicaci?n con los drivers.

			DriverAttributes attr = rvLiDAR.getDriverAttributes();

			boolean bMustClone = false;

			if (attr != null) {

				if (attr.isLoadedInMemory()) {

					bMustClone = attr.isLoadedInMemory();

				}

			}

			VectorialLegend l = (VectorialLegend) ((ClassifiableVectorial) getCapa()).getLegend();

			FBitSet bitSet = dsLidar.getSelection();

			//ajustamos el increment en funci?n del tama?o de pixel de la vista

			double resolucion = viewPort.getDist1pixel();

			int increment = 0;

			if (resolucion < 25)

				increment = (int) Math.floor(resolucion*(resolucion/3));

			else					

				increment = (int) Math.ceil(numRowsLidar / ((fullExtent.getWidth()/resolucion) * (fullExtent.getHeight()/resolucion))*(resolucion/30));

//			if (incrementAux > increment)

//				increment = incrementAux;

			if (increment < 1)

				increment = 1;

			//para que al menos pinte 5 puntos

			if (increment > numRowsLidar/5)

				increment = (int) Math.floor(numRowsLidar/5);

			int incrementAux = increment;

			int incrementFast = 400;

			if (incrementFast < incrementAux)

				incrementFast = incrementAux;

			// limites de incremento.

			int limiteIncremento = incrementFast*10;

			int limiteIncrementoFast=incrementFast*11;

			//ajustamos el grosor del punto en funci?n del tama?o de pixel de la vista

			int grosor;

			if (resolucion > 0 && resolucion < 25)

				grosor = (int) Math.round(1/(resolucion*1.5));

			else

				if(resolucion >= 25 && resolucion < 250)

					grosor=1;

				else

					if(resolucion >= 250)

						grosor=0;

					else {

						grosor=maxGrosor;

					}

			// maximo 10 de grosor

			if (grosor > maxGrosor)

				grosor = maxGrosor; 

			// minimo 0 de grosor

			if(grosor<0)

				grosor=0;

			int ii,jj,pixX,pixY;

			//contIN es el contador de puntos que caen dentro de la vista

			long contIN=0;

			//contIN es el contador de puntos que caen fuera de la vista

			long contOUT=0;

			// recorremos por incrementos

			for (int i = 0; i < numRowsLidar; i += increment) {

				// si se cancela salir del bucle

				if (cancel.isCanceled()) {

					break;

				}

				// obtener la geometria del punto i

				IGeometry geom = rvLiDAR.getShape(i);

				if (geom == null) {

					continue;

				}

				if (ct != null) {

					if (bMustClone)

						geom = geom.cloneGeometry();

					geom.reProject(ct);

				}

				ISymbol symbol = l.getSymbol(i);

				if (symbol == null)

					continue;

				if (bitSet != null)

					if (bitSet.get(i)) {

						symbol = symbol.getSymbolForSelection();

					}

				if (symbol != null) {

					// geom.draw(g, viewPort, symbol);

					FPoint2D p = (FPoint2D) geom.getInternalShape();

					Point2D.Double pOrig = new Point2D.Double(p.getX(), p.getY());

					Point2D pDest, pDest2;

					pDest = viewPort.getAffineTransform().transform(pOrig,null);

					pDest2 = g.getTransform().transform(pDest, null);

					pixX = (int) pDest2.getX();

					pixY = (int) pDest2.getY();

					if (symbol == null)

						continue;

					// pinta el pixel del grosor correspendiente

					if ((pixX > grosor) && (pixX < image.getWidth()-grosor) && (pixY > grosor) && (pixY < image.getHeight()-grosor)) {

						if (grosor == 0)

							image.setRGB(pixX, pixY, symbol.getOnePointRgb());

						else{

							for (ii=-grosor;ii<=grosor;ii++){

								for (jj=-grosor;jj<=grosor;jj++){

									image.setRGB(pixX+ii, pixY+jj, symbol.getOnePointRgb());

								}

							}

						}

					}

					// si cae dentro de la vista

					if ((pixX > 1-incrementFast) && (pixX < image.getWidth()+incrementFast) && (pixY > 1-incrementFast) && (pixY < image.getHeight()-1+incrementFast)) {

						// El primer punto despues de no entrar ningun punto tras limiteIncrementoFast cambiara el incremento

						// y retrasara el indice de recorrido de puntos.

						if (contIN == 0){

							increment = incrementAux;

							if (i>limiteIncremento)

								i=i-limiteIncremento;

						}

						// si el punto cae dentro de la vista +/- incrementFast incrementamos contIN.

						contIN ++;

						contOUT=0;

					} else { // si caen fuera de la vista y supera el limiteIncrementoFast indicado nos pasamos al incremento rapido

						if (contOUT == limiteIncrementoFast){

							contIN=0;

							increment = incrementFast;

						}

						contOUT++;

					}

				}

			}

/*

			increment = incrementAux;

			if (increment > 10)

			{

				for (int i = sc-increment/2; i > 0; i -= increment) {

					if (cancel.isCanceled()) {

						break;

					}

					IGeometry geom = adapter.getShape(i);

					if (geom == null) {

						continue;

					}

					if (ct != null) {

						if (bMustClone)

							geom = geom.cloneGeometry();

						geom.reProject(ct);

					}

					ISymbol symbol = l.getSymbol(i);

					if (symbol == null)

						continue;

					if (bitSet != null)

						if (bitSet.get(i)) {

							symbol = symbol.getSymbolForSelection();

						}

					if (symbol != null) {

						// geom.draw(g, viewPort, symbol);

						FPoint2D p = (FPoint2D) geom.getInternalShape();

						Point2D.Double pOrig = new Point2D.Double(p.getX(), p.getY());

						Point2D pDest, pDest2;

						pDest = viewPort.getAffineTransform().transform(pOrig,

								null);

						pDest2 = g.getTransform().transform(pDest, null);

						pixX = (int) pDest2.getX();

						pixY = (int) pDest2.getY();

						if (symbol == null)

							continue;

						if ((pixX > grosor) && (pixX < image.getWidth()-grosor) && (pixY > grosor) && (pixY < image.getHeight()-grosor)) 

						{

							for (ii=-grosor;ii<=grosor;ii++)

							{

								for (jj=-grosor;jj<=grosor;jj++)

								{

									image.setRGB(pixX+ii, pixY+jj, symbol.getOnePointRgb());

								}

							}

						}

						if ((pixX > 1-incrementFast) && (pixX < image.getWidth()+incrementFast) && (pixY > 1-incrementFast) && (pixY < image.getHeight()-1+incrementFast)) 

						{

							if (contIN == 0)

							{

								increment = incrementAux;

								if (i>incrementFast*10)

									i=i-incrementFast*10;

							}

							contIN ++;

							contOUT=0;

						}

						else

						{

							if (contOUT == incrementFast*11)

							{

								contIN=0;

								increment = incrementFast;

							}

							contOUT++;

						}

					}

				}

			}

			*/

			// logger.info("getCapa().getRecordset().stop()");

			if (dsLidar != null)

				dsLidar.stop();

			// logger.debug("adapter.stop()");

			rvLiDAR.stop();

			// TODO: A revisar si es o no conveniente este sistema

			// de comunicaci?n con los drivers.

			// DriverAttributes attr = adapter.getDriverAttributes();

			/*

			 * if (attr != null) { if (attr.isLoadedInMemory()) { // Quitamos lo

			 * de la reproyecci?n al vuelo para que // solo se haga una vez.

			 * getCapa().setCoordTrans(null); } }

			 */

		} catch (DriverIOException e) {

			throw new DriverException(e);

		} catch (com.hardcode.gdbms.engine.data.driver.DriverException e) {

			throw new DriverException(e);

		} catch (DriverException e) {

			throw new DriverException(e);

		}

	}

}

/* DielmoOpenLiDAR

 *

 * Copyright (C) 2008 DIELMO 3D S.L. (DIELMO) and Infrastructures  

 * and Transports Department of the Valencian Government (CIT)

 * 

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License

 * as published by the Free Software Foundation; either version 2

 * of the License, or (at your option) any later version.

 * 

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 * 

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, 

 * MA  02110-1301, USA.

 *

 * For more information, contact:

 *

 * DIELMO 3D S.L.

 * Plaza Vicente Andr?s Estell?s 1 Bajo E

 * 46950 Xirivella, Valencia

 * SPAIN

 *   

 * +34 963137212

 * dielmo@dielmo.com

 * www.dielmo.com

 * 

 * or

 * 

 * Generalitat Valenciana

 * Conselleria d'Infraestructures i Transport

 * Av. Blasco Ib??ez, 50

 * 46010 VALENCIA

 * SPAIN

 *

 * +34 963862235

 * gvsig@gva.es

 * www.gvsig.gva.es

 */

/*

 * AUTHORS (In addition to DIELMO and CIT):

 *  

 */

package com.dielmo.gvsig.lidar.drivers;

import java.awt.geom.Point2D;

import java.awt.geom.Rectangle2D;

import java.io.File;

import java.io.FileInputStream;

import java.io.FileNotFoundException;

import java.io.FileOutputStream;

import java.io.IOException;

import java.nio.ByteOrder;

import java.nio.channels.FileChannel;

import java.util.Properties;

import com.dielmo.lidar.InicializeLidar;

import com.dielmo.lidar.LASHeader_1X;

import com.dielmo.lidar.LidarHeader;

import com.dielmo.lidar.LidarPoint;

import com.hardcode.driverManager.Driver;

import com.hardcode.gdbms.driver.DriverUtilities;

import com.hardcode.gdbms.engine.data.DataSourceFactory;

import com.hardcode.gdbms.engine.data.driver.DriverException;

import com.hardcode.gdbms.engine.data.driver.ObjectDriver;

import com.hardcode.gdbms.engine.data.edition.DataWare;

import com.hardcode.gdbms.engine.values.Value;

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

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

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

import com.iver.cit.gvsig.fmap.drivers.BoundedShapes;

import com.iver.cit.gvsig.fmap.drivers.DriverAttributes;

import com.iver.cit.gvsig.fmap.drivers.FieldDescription;

import com.iver.cit.gvsig.fmap.drivers.ITableDefinition;

import com.iver.cit.gvsig.fmap.drivers.VectorialFileDriver;

import com.iver.cit.gvsig.fmap.edition.EditionException;

import com.iver.cit.gvsig.fmap.edition.IRowEdited;

import com.iver.cit.gvsig.fmap.edition.ISpatialWriter;

import com.iver.cit.gvsig.fmap.edition.IWriteable;

import com.iver.cit.gvsig.fmap.edition.IWriter;

import com.iver.cit.gvsig.fmap.layers.FLayer;

import com.iver.cit.gvsig.fmap.layers.FLyrVect;

import com.iver.utiles.bigfile.BigByteBuffer2;

/**

 * Driver for managing original data LiDAR

 * 

 * @author Oscar Garcia

 */

public class LiDARDriver implements VectorialFileDriver, ObjectDriver, BoundedShapes,

IWriteable, ISpatialWriter {

	/**

	 * Driver name.

	 */

	public static final String driverName = "gvSIG LIDAR driver";

	// Variables para el manejo del fichero LiDAR

	/**

	 * LiDAR file.

	 */

	private File m_Fich;

	/**

	 * Temporal LiDAR file for writer. This is used in edition time.

	 */

	private File fTemp;

	/**

	 * 8 Kbytes buffer

	 */

	private BigByteBuffer2 bb;

	/**

	 * Channel to read, write and manipulate the LiDAR file 

	 */

	private FileChannel channel;

	/**

	 * management of input read data from LiDAR file. 

	 */

	private FileInputStream fin;

	// informacion del LiDAR

	/**

	 * fullExtent of LiDAR layer.

	 */

	private Rectangle2D fullExtent;

	/**

	 * Definition of one type of LiDAR point.

	 */

	private LidarPoint lp;

	/**

	 * Definition of one type of LiDAR header.

	 */

	private LidarHeader hdr;

	/**

	 * Description of fields LiDAR

	 */ 

	private FieldDescription[] fields;

	// Writer

	/**

	 * Writer assigned to LiDAR

	 */

	private LiDARWriter lidarWriter = new LiDARWriter();

	/**

	 * Temporal folder to work in edition mode.

	 */

	private static String tempDirectoryPath = System.getProperty("java.io.tmpdir");

	/**

	 * Function that test if passed layer is controlled by driver LiDARDriver

	 * 

	 * @param layer layer to test

	 * @return true if layer is controlled by driver LiDARDriver, false in other case

	 */

	public static boolean isLidarLayer(FLayer layer) {

		if (layer instanceof FLyrVect && layer.isAvailable()) {

			FLyrVect lyrVect = (FLyrVect) layer;

			//ReadableVectorial rv = lyrVect.getSource();

			//VectorialDriver driver = lyrVect.getSource().getDriver();

			Driver driver = lyrVect.getSource().getDriver();

			if(driver==null)

				return false;

			if (driver.getName().compareTo(driverName) == 0) {

				return true;

			}

		}

		return false;

	}

	/**

	 * return the LidarHeader of this layer

	 */

	public LidarHeader getLidarHeader() {

		return hdr;

	}

	/**

	 * return a new instance of LidarPoint type of this layer

	 */

	public LidarPoint getLidarPoint() {

		return lp;

	}

	// VectorialFileDriver Methods

	public void initialize() throws IOException {

		File file = new File(m_Fich.getAbsolutePath());

		hdr = InicializeLidar.InizializeLidarHeader(file);

		if(hdr == null)

			throw new IOException();

		lp = InicializeLidar.InizializeLidarPoint(file);

		if(lp == null)

			throw new IOException();

		// la informacion de fullExtent la contiene la cabecera

		fullExtent = new Rectangle2D.Double(hdr.getMinX(), hdr.getMinY(),

				(hdr.getMaxX()-hdr.getMinX()),

				(hdr.getMaxY()-hdr.getMinY()));

		// obtiene la estructura de tabla

		setFields();

	}

	/*

	 * (non-Javadoc)

	 *

	 * @see com.iver.cit.gvsig.fmap.drivers.MemoryDriver#accept(java.io.File)

	 */

	public boolean accept(File f) {

		return ((f.getName().toUpperCase().endsWith("LAS")) || (f.getName().toUpperCase().endsWith("BIN")));

	}

	public void close() throws IOException {

/*		IOException ret = null;

		try {

			channel.close();

		} catch (IOException e) {

			ret = e;

		} finally {

			try {

				fin.close();

			} catch (IOException e1) {

				ret = e1;

			}

		}

		if (ret != null) {

			throw ret;

		}

		else // Si todo ha ido bien, preparamos para liberar memoria.

        {

		    bb = null;

        }

		*/

	}

	public File getFile() {

		return m_Fich;

	}

	/*

	 * (non-Javadoc)

	 *

	 * @see com.iver.cit.gvsig.fmap.drivers.MemoryDriver#open(java.io.File)

	 */

	public void open(File f) throws IOException {

		m_Fich = f;

		fin = new FileInputStream(f);

		// Open the file and then get a channel from the stream

		channel = fin.getChannel();

		// Get the file's size and then map it into memory

		// bb = channel.map(FileChannel.MapMode.READ_ONLY, 0, size);

        bb = new BigByteBuffer2(channel, FileChannel.MapMode.READ_ONLY);

        bb.order(ByteOrder.LITTLE_ENDIAN);

	}

	/*

	 * (non-Javadoc)

	 *

	 * @see com.iver.cit.gvsig.fmap.drivers.VectorialDriver#getDriverAttributes()

	 */

	public DriverAttributes getDriverAttributes() {

		return null;

	}

	/* (non-Javadoc)

	 * @see com.iver.cit.gvsig.fmap.drivers.VectorialDriver#getFullExtent()

	 */

	public Rectangle2D getFullExtent() throws IOException {

		return fullExtent;

	}

	/* (non-Javadoc)

	 * @see com.iver.cit.gvsig.fmap.drivers.VectorialDriver#getShape(int)

	 */

	public IGeometry getShape(int index) {

		Point2D.Double p = null;

		p = lp.readPoint2D(bb, hdr, index);

		return ShapeFactory.createPoint2D(p.getX(), p.getY());

	}

	public int getShapeCount() throws IOException {	

		return (int)hdr.getNumPointsRecord();

	}

	/*

	 * (non-Javadoc)

	 *

	 * @see com.iver.cit.gvsig.fmap.drivers.MemoryDriver#getShapeType()

	 */

	public int getShapeType() {

		return FShape.POINT;

	}

	/**

	 * Indica si el fichero se puede modificar.

	 */

	public boolean isWritable() {

		return m_Fich.canWrite();

	}

	 /* (non-Javadoc)

     * @see com.iver.cit.gvsig.fmap.drivers.VectorialDriver#reLoad()

     */

    public void reload() throws DriverException, IOException {

    	/*

    	 * Codigo para cerrar los ficheros antes de intentar recargarlos

    	 */

    	IOException ret = null;

		try {

			channel.close();

		} catch (IOException e) {

			ret = e;

		} finally {

			try {

				fin.close();

			} catch (IOException e1) {

				ret = e1;

			}

		}

		if (ret != null) {

			throw ret;

		} else { 

			// Si todo ha ido bien, preparamos para liberar memoria.

		    bb = null;

        }

    	open(m_Fich);

		initialize();

    }

	/*

	 * (non-Javadoc)

	 *

	 * @see com.iver.cit.gvsig.fmap.drivers.MemoryDriver#getName()

	 */

	public String getName() {

		return driverName;

	}

	// ObjectDriver Methods			     		

	public int[] getPrimaryKeys() throws DriverException {

		// TODO Auto-generated method stub

		return null;

	}

	public void write(DataWare dataWare) throws DriverException {

		// TODO Auto-generated method stub

	}

	public void setDataSourceFactory(DataSourceFactory dsf) {

		// TODO Auto-generated method stub

	}

	public int getFieldCount() throws DriverException {

		return fields.length;

	}

	public String getFieldName(int fieldId) throws DriverException {

		return fields[fieldId].getFieldName();

	}

	public int getFieldType(int i) throws DriverException {

		return fields[i].getFieldType();

	}

	public Value getFieldValue(long rowIndex, int fieldId) throws DriverException {

		return lp.getFieldValueByIndex(bb, fieldId, hdr, rowIndex);

	}

	public int getFieldWidth(int i) throws DriverException {

		return fields[i].getFieldLength();

	}

	public long getRowCount() throws DriverException {

		return (int)hdr.getNumPointsRecord();

	}

	private void setFields(){

		fields = lp.getFieldDescription();

	}

	//IWriteable Methods

	public IWriter getWriter() {

		return this;

	}

	//ISpatialWriter Methods

	public boolean canWriteGeometry(int gvSIGgeometryType) {

		return lidarWriter.canWriteGeometry(gvSIGgeometryType);

	}

	public boolean canAlterTable() {

		return false;

	}

	public boolean canSaveEdits() {

		return lidarWriter.canSaveEdits();

	}

	public boolean canWriteAttribute(int sqlType) {

		return lidarWriter.canWriteAttribute(sqlType);

	}

	public String getCapability(String capability) {

		return lidarWriter.getCapability(capability);

	}

	public void setCapabilities(Properties capabilities) {

		lidarWriter.setCapabilities(capabilities);

	}

	public ITableDefinition getTableDefinition() {

		return lidarWriter.getTableDefinition();

	}

	public void initialize(ITableDefinition tableDefinition)

			throws EditionException {

		// escribe en un temporal el fichero.

		int aux = (int)(Math.random() * 1000);

		String extension;

		if(hdr instanceof LASHeader_1X)

			extension= ".las";

		else

			extension = ".bin";

		fTemp = new File(tempDirectoryPath + "/tmpLidar" + aux + extension);

		lidarWriter.setFile(fTemp);

		lidarWriter.setHeaderAndPoint(hdr, lp);

		lidarWriter.initialize(tableDefinition);

	}

	public boolean isWriteAll() {

		return true;

	}

	/**

	 * Trabajo a realizar antes de empezar a recorrer las geometrias.

	 */

	public void preProcess() throws EditionException {

		lidarWriter.preProcess();

	}

	/**

	 * Trabajo a realizar durante recorremos las geometrias.

	 */

	public void process(IRowEdited row) throws EditionException {

		lidarWriter.process(row);

	}

	/**

	 * Trabajo a realizar despues de terminar de recorrer las geometrias.

	 */

	public void postProcess() throws EditionException {

		lidarWriter.postProcess();

		try {

			// close();

			FileChannel fcinLidar = new FileInputStream(fTemp).getChannel();

			FileChannel fcoutLidar = new FileOutputStream(m_Fich).getChannel();

			DriverUtilities.copy(fcinLidar, fcoutLidar);

			// Borramos los temporales

			fTemp.delete();

			//reload();

		} catch (FileNotFoundException e) {

			throw new EditionException(e);

		} catch (IOException e) {

			throw new EditionException(e);

		} 

	}

	// BoundedShapes Methods

	public Rectangle2D getShapeBounds(int index) throws IOException {

		Point2D p = new Point2D.Double();

		Rectangle2D BoundingBox = new Rectangle2D.Double();

		p = lp.readPoint2D(bb, hdr, index);

		BoundingBox = new Rectangle2D.Double(p.getX() - 0.1,

				p.getY() - 0.1, 0.2, 0.2);

		return BoundingBox;

	}

	public int getShapeType(int index) {

		return FShape.POINT;

	}

}

/* DielmoOpenLiDAR

 *

 * Copyright (C) 2008 DIELMO 3D S.L. (DIELMO) and Infrastructures  

 * and Transports Department of the Valencian Government (CIT)

 * 

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License

 * as published by the Free Software Foundation; either version 2

 * of the License, or (at your option) any later version.

 * 

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 * 

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, 

 * MA  02110-1301, USA.

 *

 * For more information, contact:

 *

 * DIELMO 3D S.L.

 * Plaza Vicente Andr?s Estell?s 1 Bajo E

 * 46950 Xirivella, Valencia

 * SPAIN

 *   

 * +34 963137212

 * dielmo@dielmo.com

 * www.dielmo.com

 * 

 * or

 * 

 * Generalitat Valenciana

 * Conselleria d'Infraestructures i Transport

 * Av. Blasco Ib??ez, 50

 * 46010 VALENCIA

 * SPAIN

 *

 * +34 963862235

 * gvsig@gva.es

 * www.gvsig.gva.es

 */

/*

 * AUTHORS (In addition to DIELMO and CIT):

 *  

 */

package com.dielmo.gvsig.lidar.drivers;

import java.awt.geom.Rectangle2D;

import java.io.File;

import java.io.IOException;

import java.io.RandomAccessFile;

import java.nio.ByteBuffer;

import java.nio.channels.FileChannel;

import java.nio.channels.WritableByteChannel;

import java.sql.Types;

import com.dielmo.lidar.LidarHeader;

import com.dielmo.lidar.LidarPoint;

import com.hardcode.gdbms.engine.values.DoubleValue;

import com.hardcode.gdbms.engine.values.Value;

import com.hardcode.gdbms.engine.values.ValueFactory;

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

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

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

import com.iver.cit.gvsig.fmap.drivers.FieldDescription;

import com.iver.cit.gvsig.fmap.edition.EditionException;

import com.iver.cit.gvsig.fmap.edition.IRowEdited;

import com.iver.cit.gvsig.fmap.edition.ISpatialWriter;

import com.iver.cit.gvsig.fmap.edition.writers.AbstractWriter;

/**

 * Writer of LiDAR.

 * 

 * @author Oscar Garcia

 */

public class LiDARWriter extends AbstractWriter implements ISpatialWriter {

	private String lidarPath;

	private File file;

	private LidarHeader hdr;

	private LidarPoint lp;

	private int numRows;

	private ByteBuffer bb = null;

	private FileChannel lidarChannel;

	private Rectangle2D fullExtent;

	public LiDARWriter() {

		super();

	}

	/**

	 * La tabla Lidar no se deve alterar, por lo que

	 * Esta funcion devolvera false siempre.

	 */

	public boolean canAlterTable() {

		return false;

	}

	/**

	 * Informa de si el fichero se puede editar o no

	 */

	public boolean canSaveEdits() {

		return file.canWrite();

	}

	/**

	 * Indica que atributos se pueden cambiar.

	 */

	public boolean canWriteAttribute(int sqlType) {

		switch (sqlType) {

			case Types.DOUBLE:

			case Types.FLOAT:

			case Types.INTEGER:

			case Types.BIGINT:

				return true;

			case Types.DATE:

				return false;

			case Types.BIT:

			case Types.BOOLEAN:

				return false;

			case Types.VARCHAR:

			case Types.CHAR:

			case Types.LONGVARCHAR:

				return false; 

		}

		return false;

	}

	/**

	 * Seteamos el fichero sobre el que trabajaremos en la escritura.

	 * @param f fichero de trabajo.

	 */

	public void setFile(File f) {

		try {

			lidarPath = f.getAbsolutePath();

			lidarChannel = (FileChannel) getWriteChannel(lidarPath);

			file = f;

		} catch (IOException e) {

			// TODO Auto-generated catch block

			e.printStackTrace();

		}

	}

	/**

	 * Seteamos las caracteristicas del Lidar.

	 * @param h Cabecera lidar.

	 * @param p Punto lidar.

	 */

	public void setHeaderAndPoint(LidarHeader h, LidarPoint p) {

		hdr = h;

		lp = p;

	}

	/**

	 * Obtiene el canal de escritura.

	 * 

	 * @param path ruta del fichero en el que queremos obtener el canal de escritura.

	 * @return Canal de escritura del fichero dado.

	 * @throws IOException

	 */

	private WritableByteChannel getWriteChannel(String path)

	throws IOException {

		// FileChannel de escritura.

		WritableByteChannel channel;

		File f = new File(path);

		if (!f.exists()) {

			System.out.println("Creando fichero " + f.getAbsolutePath());

			// crear el fichero si no existia.

			if (!f.createNewFile()) {

				System.err.print("Error al crear el fichero " +

					f.getAbsolutePath());

				throw new IOException("Cannot create file " + f);

			}

		}

		// Obtenemos un canal de lectura escritura de acceso aleatorio.

		RandomAccessFile raf = new RandomAccessFile(f, "rw");

		channel = raf.getChannel();

		return channel;

	}

	/**

	 * devuelve true si puede escribir la geometria dada.

	 * Este driver solo devolvera true para las geomerias de punto.

	 */

	public boolean canWriteGeometry(int gvSIGgeometryType) {

		switch (gvSIGgeometryType) {

			case FShape.POINT:

				return true;

			case FShape.MULTIPOINT:

				return false;

		}

		return false;

	}

	/**

	 * Make sure our buffer is of size.

	 *

	 * @param size, size that buffer must contain

	 */

	private void checkShapeBuffer(int size) {

		if (bb.capacity() < size) {

			bb = ByteBuffer.allocateDirect(size);

		}

	}

	/**

	 * Drain internal buffers into underlying channels.

	 *

	 * @throws IOException DOCUMENT ME!

	 */

	private void drain() throws IOException {

		bb.flip();

		while (bb.remaining() > 0)

			lidarChannel.write(bb);

		bb.flip().limit(bb.capacity());

	}

	/**

	 * DOCUMENT ME!

	 */

	private void allocateBuffer() {

		bb = ByteBuffer.allocateDirect(16 * 1024);

	}

	/**

	 * Close the underlying Channels.

	 *

	 * @throws IOException DOCUMENT ME!

	 */

	public void close() throws IOException {

		lidarChannel.close();

		lidarChannel = null;

		bb = null;

	}

	// reservar bytes para la cabecera

	public void preProcess() throws EditionException {

		// Por ahora solo escribimos los primeros bytes

		// de las cabeceras. Luego en el postprocess los escribiremos

		// correctamente, con el numero de

		// registros que tocan.

		try {

			numRows = 0;

			if (bb == null) {

				allocateBuffer();

			}

			// Posicionamos al principio.

			bb.position(0);

			checkShapeBuffer((int)hdr.getOffsetData());

			byte b[] = new byte[(int) hdr.getOffsetData()];

			bb.put(b);

			lidarChannel.position(0);

			//hdr.writeLidarHeader(bb);

			fullExtent = null;

			drain();

			// seteamos la Z

			hdr.setMaxZ(Double.MIN_VALUE);

			hdr.setMinZ(Double.MAX_VALUE);

		} catch (IOException e) {

			// TODO Auto-generated catch block

			e.printStackTrace();

		}			

	}

	// cabecera

	public void postProcess() throws EditionException {

		if (bb == null) {

			allocateBuffer();

		}

		// seteamos la cabecera

		hdr.setNumPointsRecord(numRows);

		hdr.setMaxX(fullExtent.getMaxX());

		hdr.setMaxY(fullExtent.getMaxY());

		hdr.setMinX(fullExtent.getMinX());

		hdr.setMinY(fullExtent.getMinY());

		try {

			lidarChannel.position(0);

			hdr.writeLidarHeader(bb);

			drain();

			lidarChannel.close();

		} catch (IOException e) {

			// TODO Auto-generated catch block

			e.printStackTrace();

		}

	}

	// datos

	public void process(IRowEdited row) throws EditionException {

		if(row.getStatus() == IRowEdited.STATUS_DELETED) {

			return;

		}

		try {

			IFeature feat = (IFeature) row.getLinkedRow();

			IGeometry theGeom = feat.getGeometry();

			Value[] attrs = row.getAttributes();

			if (bb == null) {

				allocateBuffer();

				lidarChannel.position(0);

			}

			// must allocate enough for point

			checkShapeBuffer(lp.getSizeFormat());

			Rectangle2D boundsLidar = theGeom.getBounds2D();

			// NOTA: estamo suponiendo que la posicion 0 y la 1 siempe tendra los valores de x e y de la geometria.

			attrs[0]=ValueFactory.createValue(boundsLidar.getMinX());

			attrs[1]=ValueFactory.createValue(boundsLidar.getMinY());

			lp.setPoint(attrs, hdr);

			lp.WritePoint(bb);

			// NOTA: estamos suponiendo que la columna dos del valor de la tabla es la Z.. OJO, cambiar mas adelante, a?adir un get indexByName o algo parecido

			if(hdr.getMaxZ()<((DoubleValue)(attrs[2])).getValue() )

				hdr.setMaxZ(((DoubleValue)(attrs[2])).getValue());

			if(hdr.getMinZ()>((DoubleValue)(attrs[2])).getValue() )

				hdr.setMinZ(((DoubleValue)(attrs[2])).getValue());

			if (fullExtent == null) {

				fullExtent = boundsLidar;

			} else {

				fullExtent.add(boundsLidar);

			}

			drain();

			numRows++;

		} catch (IOException e) {

			// TODO Auto-generated catch block

			e.printStackTrace();

		}

	}

	public String getName() {

		return "LiDAR Writer";

	}

}

/* DielmoOpenLiDAR

 *

 * Copyright (C) 2008 DIELMO 3D S.L. (DIELMO) and Infrastructures  

 * and Transports Department of the Valencian Government (CIT)

 * 

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License

 * as published by the Free Software Foundation; either version 2

 * of the License, or (at your option) any later version.

 * 

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 * 

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, 

 * MA  02110-1301, USA.

 *

 * For more information, contact:

 *

 * DIELMO 3D S.L.

 * Plaza Vicente Andr?s Estell?s 1 Bajo E

 * 46950 Xirivella, Valencia