Commit c8f5aa48 authored by Luis Peñaranda's avatar Luis Peñaranda
Browse files

read file names and paths from rc file

parent fca0faf5

README

+8 −0
Original line number Diff line number Diff line
@@ -9,3 +9,11 @@ it was not tested). It requires: 
-glut or freeglut.



To build, simply run qmake and make.



To configure, you can set in the file ~/.panorc the following options.

        shader_dir=<path to directory containing the shader files>

        image_file=<path to the desired input file>

Lines in the file must start with option names, and no spaces should go

between option names, equal signs and values. If no shader path is set, the

default is ./shaders/. If no input file is set, or the file is missing, a

file chooser will be shown at startup.

openglcanvas.cpp

+74 −41
Original line number Diff line number Diff line
@@ -4,20 +4,23 @@ 
#endif

#include "openglcanvas.h"

#include <cmath>

#include <unistd.h>     // for getcwd, getpwuid, getuid

#include <sys/types.h>  // for fstat, getpwuid, getuid

#include <sys/stat.h>   // for fstat

#include <pwd.h>        // for getpwuid (TODO: windows?)

#include <cstdio>       // for fopen, fclose, getc

#include <cstring>

#ifdef WINDOWS

  #include <direct.h>

  #define GET_WORKDIR _getcwd

#else

  #include <unistd.h>

  // unistd was included above

  #define GET_WORKDIR getcwd

#endif

#include <sys/types.h> // for fstat

#include <sys/stat.h>  // for fstat



#define PROGNAME "pano_interface"

#define INPUT_IMAGE_FILE "input_images/image_4_input.pnm"

#define VERT_SHADER_FILE "shaders/test_vertex_shader.vert"

#define FRAG_SHADER_FILE "shaders/fragment_shader.frag"

#define VERT_SHADER_FILE "test_vertex_shader.vert"

#define FRAG_SHADER_FILE "fragment_shader.frag"



OpenGLCanvas::OpenGLCanvas(QWidget *parent) :

    QGLWidget(parent)
@@ -107,6 +110,51 @@ void OpenGLCanvas::change_visualization(QString name){ 


}



// This function reads the contents of the ~/.panorc file and stores the

// options in private variables.

// TODO: windows

void OpenGLCanvas::read_config_file(){

    struct passwd *pw=getpwuid(getuid());

    char *filepath=pw->pw_dir;

    strcat(filepath,"/.panorc");

    shader_dir=(char*)malloc(512*sizeof(char));

    shader_dir[0]='\0';

    input_image_file=(char*)malloc(512*sizeof(char));

    input_image_file[0]='\0';

    struct stat testbuf;

    if(stat(filepath,&testbuf)){

        fprintf(stderr,"~/.panorc does not exist\n");

    }else{

        FILE *rcfile=fopen(filepath,"r");

        char c;

        char *line=(char*)malloc(512*sizeof(char));

        while((c=getc(rcfile))!=EOF){

            while(c=='\n') // discard empty lines

                c=getc(rcfile);

            if(c==EOF)

                break;

            line[0]=c; // first char on the line was already read

            if(!fgets(line+1,511,rcfile)){

                fprintf(stderr,"error reading rcfile\n");

                exit(-1);

            }

            // check for 'shader_dir' option

            if(!strncmp(line,"shader_dir=",11)){

                strcpy(shader_dir,line+11);

                shader_dir[strlen(line)-12]='\0';

                fprintf(stderr,"shader_dir=%s\n",shader_dir);

            }

            // check for 'image_file' option

            if(!strncmp(line,"image_file=",11)){

                strcpy(input_image_file,line+11);

                input_image_file[strlen(line)-12]='\0';

                fprintf(stderr,"input_image_file=%s\n",input_image_file);

            }

        }

        fclose(rcfile);

    }

}



void OpenGLCanvas::load_image(const char *new_image){

    const char * const progname=(char*)(PROGNAME);

    int textureSize=getTextureSize(progname,new_image);
@@ -135,33 +183,23 @@ void OpenGLCanvas::initializeGL(){ 
    glDepthFunc(GL_LEQUAL);

    glHint(GL_PERSPECTIVE_CORRECTION_HINT,GL_NICEST);



    char *input_image=(char*)malloc(512*sizeof(char*));

    if(!GET_WORKDIR(input_image,512)){

        fprintf(stderr,"too long pathname\n");

        exit(-1);

    };

    strcat(input_image,"/\0");

    strcat(input_image,INPUT_IMAGE_FILE);

#ifdef __APPLE__

    const char * const progname = "PROJ_ROOT_DIR";

    //const char * input_image = INPUT_IMAGE_FILE;

#else

    // progname is a file name or a path???

    const char * const progname = (char*)(PROGNAME);

    //const char * input_image = (char*)(INPUT_IMAGE_FILE);

#endif



    fprintf(stderr,"progname=%s\n",progname);

    fprintf(stderr,"default image=%s\n",input_image);

    // what to do if the input file does not exist

    read_config_file();

    // If the input file does not exist or was not specified.

    struct stat testbuf;

    if(stat(input_image,&testbuf)){

        fprintf(stderr,"the default image file does not exist!\n");

    if(stat(input_image_file,&testbuf)||!strcmp(input_image_file,"")){

        load_image(QFileDialog::getOpenFileName(this,tr("Choose Panorama File")).toStdString().c_str());

    }else{

        load_image(input_image);

        load_image(input_image_file);

    }

    free(input_image);

    free(input_image_file);



    // mesh resolution

    int m,n;
@@ -499,23 +537,25 @@ void OpenGLCanvas::setShaders() { 
    GLuint v = glCreateShader(GL_VERTEX_SHADER);

    GLuint f = glCreateShader(GL_FRAGMENT_SHADER);



    // Configure vertex and fragment shader files.

    char *vs_file=(char*)malloc(512*sizeof(char*));

    if(!GET_WORKDIR(vs_file,512)){

        fprintf(stderr,"too long pathname\n");

        exit(-1);

    };

    strcat(vs_file,"/\0");

    strcat(vs_file,VERT_SHADER_FILE);

    fprintf(stderr,"vs_file=%s\n",vs_file);



    char *fs_file=(char*)malloc(512*sizeof(char*));

    if(!GET_WORKDIR(fs_file,512)){

        fprintf(stderr,"too long pathname\n");

    if(!strcmp(shader_dir,"")){ // if shader_dir was not configured

        if(!GET_WORKDIR(vs_file,512)||!GET_WORKDIR(fs_file,512)){

            fprintf(stderr,"error reading shader files\n");

            exit(-1);

    };

    strcat(fs_file,"/\0");

        }

        strcat(vs_file,"/shaders/");

        strcat(fs_file,"/shaders/");

    }else{;

        strcpy(vs_file,shader_dir);

        strcat(vs_file,"/");

        strcpy(fs_file,shader_dir);

        strcat(fs_file,"/");

    }

    strcat(vs_file,VERT_SHADER_FILE);

    strcat(fs_file,FRAG_SHADER_FILE);

    fprintf(stderr,"fs_file=%s\n",fs_file);

    fprintf(stderr,"vs_file=%s\nfs_file=%s\n",vs_file,fs_file);



    struct stat vs_testbuf,fs_testbuf;

    if(stat(vs_file,&vs_testbuf)||stat(fs_file,&fs_testbuf)){
@@ -525,15 +565,8 @@ void OpenGLCanvas::setShaders() { 
        exit(-1);

    }



//#ifdef __APPLE__

    // in Mac

    //vs = textFileRead(VERT_SHADER_FILE);

    //fs = textFileRead(FRAG_SHADER_FILE);

//#else

    // in Linux (I think this would also work in mac, I just need to try)

    vs=textFileRead(vs_file);

    fs=textFileRead(fs_file);

//#endif



    const char * vv = vs;

    const char * ff = fs;

openglcanvas.h

+5 −0
Original line number Diff line number Diff line
@@ -41,6 +41,7 @@ public: 
    explicit OpenGLCanvas(QWidget *parent = 0);



protected:

    void read_config_file();

    void load_image(const char *new_image);

    void initializeGL();

    void resizeGL(int w, int h);
@@ -88,6 +89,10 @@ private: 
    float * textureCoordinates;

    //float windowWidth;

    //float windowHeight;



    // options set in the rc file

    char* shader_dir;

    char* input_image_file;

};



#endif // OPENGLCANVAS_H