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.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;

        }

}