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

        }

}