filereader.cpp

Go to the documentation of this file.

/****************************************************************************
**
** Author:  Jaime Valls Miro <jaime.vallsmiro@eng.uts.edu.au>
**          Hue Tuan Thi <huetuan.thi@uts.edu.au>, (C) 2006
**
** This file is part of the S3D Viewer Project
**
** This file may be used under the terms of the GNU General Public
** License version 2.0 as published by the Free Software Foundation
** and appearing in the file LICENSE.GPL included in the packaging of
** this file.  Please review the following information to ensure GNU
** General Public Licensing requirements will be met:
** http://www.trolltech.com/products/qt/opensource.html
**
** If you are unsure which license is appropriate for your use, please
** review the following information:
** http://www.trolltech.com/products/qt/licensing.html or contact the
** sales department at sales@trolltech.com.
**
** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
**
****************************************************************************/

#include "filereader.h"


FileReader::FileReader()
{
}

FileReader::~FileReader()
{
}

void FileReader::readFile(QString &fileName)
{
    // convert fileName to string
    const char *file = fileName.toLatin1 ();

    // open file under READ ONLY mode
    int fich=open(file,O_RDONLY);
    if(fich<0){
        qDebug("Error: file not found.");
        return;
    }

    // initiate head structure
    head=(S3DHead*)malloc(sizeof(S3DHead));
    // number of bytes read
    int br=read(fich,head,sizeof(S3DHead)); 

    // error reading control
    if(br!=sizeof(S3DHead)){
        qDebug("Error: file corrupt.");
        return;
    }

    // Gray image (if the file contains it)
    if(head->encoding==0 && head->colorFormat==0){
        int npix=head->nrow*head->ncol;
        image_bw=(TPixelBW*)malloc(sizeof(TPixelBW)*npix);
        br=read(fich,image_bw,sizeof(TPixelBW)*npix);

        //error reading control
        if(br!=(int)sizeof(TPixelBW)*npix){
            qDebug("Error: file corrupt.");
            return;
        }
    }

    // color format for info purpose
    if(head->colorFormat == 0)
        colorFormatText = "Black and White";
    else
        colorFormatText = "Color RGB";

    // Color image (if the file contains it)
    TPixelColor *image_color=NULL;
    if(head->encoding==0 && head->colorFormat==1){
        int npix=head->nrow*head->ncol;
        image_color=(TPixelColor*)malloc(sizeof(TPixelColor)*npix);
        br=read(fich,image_color,sizeof(TPixelColor)*npix);

        // error reading control
        if(br!=(int)sizeof(TPixelColor)*npix){
            qDebug("Error: file corrupt.");
            return;
        }
    }

    // 3D Points
    TPoint3D *points=NULL;
    if(head->np>0){
        points=(TPoint3D*)malloc(sizeof(TPoint3D)*head->np);
        br=read(fich,points,sizeof(TPoint3D)*head->np);

        //error reading control
        if(br!=(int)sizeof(TPoint3D)*head->np){
            if(image_bw) free(image_bw);
            if(image_color) free(image_color);
            qDebug("Error: file corrupt.");
            return;
        }
    }

    // At this point, we have read all of the file data
    close(fich);

    // Image (if exists)
    if(head->encoding==0){
        for(int i=0;i<head->nrow;i++){
            for(int j=0;j<head->ncol;j++){
                if(head->colorFormat==0){ //Black and white case
                    TPixelBW p=image_bw[ i*head->ncol+j ];
                    imagePixels[i][j][0] = (GLubyte) ( p.color );
                    imagePixels[i][j][1] = (GLubyte) ( p.color );
                    imagePixels[i][j][2] = (GLubyte) ( p.color );
                }else{                    //Color RGB case
                    TPixelColor p=image_color[ i*head->ncol+j ];
                    imagePixels[i][j][0] = (GLubyte) ( p.r );
                    imagePixels[i][j][1] = (GLubyte) ( p.g );
                    imagePixels[i][j][2] = (GLubyte) ( p.b );
                }
            }
        }
    }

    // 3D points
    if(head->encoding==0){
        for(int i=0;i<head->np;i++){
            // we show the 3D coordinates (XYZ) and the image coordinates (IJ) of the points
            TPoint3D p=points[i];
            pointArray[i][0] = p.x; // x coord
            pointArray[i][1] = p.y; // y coord
            pointArray[i][2] = p.z; // z coord
            pointArray[i][3] = (int) p.info2d/head->ncol; // x reference image coord
            pointArray[i][4] = (int) ( p.info2d - pointArray[i][3] * head->ncol ); // y coord
        }
    }else{
        if(head->colorFormat==0){ // point cloud with gray levels
            for(int i=0;i<head->np;i++){
                TPoint3D p=points[i];
                pointArray[i][0] = p.x;
                pointArray[i][1] = p.y;
                pointArray[i][2] = p.z;
                pointArray[i][3] = p.info2d;
                pointArray[i][4] = p.info2d;
                pointArray[i][5] = p.info2d;
            }
        }else{                    // point cloud with color rgb values
            for(int i=0;i<head->np;i++){
                TPoint3D p=points[i];
                int r,g,b;
                r=(p.info2d & 0xff0000)>>16;
                g=(p.info2d & 0xff00)>>8;
                b=(p.info2d & 0xff);

                pointArray[i][0] = p.x;
                pointArray[i][1] = p.y;
                pointArray[i][2] = p.z;
                pointArray[i][3] = r;
                pointArray[i][4] = g;
                pointArray[i][5] = b;
            }
        }
    }
}

QString FileReader::getInfo()
{
    return QString( head->info );
}

int FileReader::getColorFormat()
{
    return head->colorFormat;
}

QString FileReader::getColorText()
{
    return colorFormatText;
}

int FileReader::getNRow()
{
    return head->nrow;
}

int FileReader::getNCol()
{
    return head->ncol;
}

int FileReader::getNp()
{
    return head->np;
}

int FileReader::getEncoding()
{
    return head->encoding;
}

char FileReader::getColor()
{
    return image_bw->color;
}

char FileReader::getR()
{
    return image_color->r;
}

char FileReader::getG()
{
    return image_color->g;
}

char FileReader::getB()
{
    return image_color->b;
}

float FileReader::getX()
{
    return points->x;
}

float FileReader::getY()
{
    return points->y;
}

float FileReader::getZ()
{
    return points->z;
}

int FileReader::getInfo2d()
{
    return points->info2d;
}

---