Envi.cpp

Go to the documentation of this file.

#include "Envi.h"

#include <fstream>
#include <iostream>

#include <cstring>
#include <cstdlib>
#include <cstdint>

#include <sys/stat.h>
#include <sys/types.h>
#include <sys/mman.h>
#include <unistd.h>
#include <fcntl.h>

EnviFile::EnviFile(const std::string & _filename) :
    filename(_filename), data(nullptr), fd(-1),
    width(0), height(0), numFrames(0), bytesPerPixel(0) {
    loadImage();
}

EnviFile::EnviFile() :
    EnviFile("") {
}

EnviFile::~EnviFile() {
    closeFile();
}

unsigned long long EnviFile::getWidth() const { return width; }
unsigned long long EnviFile::getHeight() const { return height; }
unsigned long long EnviFile::getNumFrames() const { return numFrames; }
unsigned int EnviFile::getBytesPerPixel() const { return bytesPerPixel; }
double EnviFile::getTint() const { return tint; }
double EnviFile::getFps() const { return fps; }

void *EnviFile::getDataByFrame(unsigned int frame) const {
    if(data == nullptr)
        return NULL;
    return ((char*)data)+(width*height*bytesPerPixel*frame);
}

void EnviFile::openFile(const std::string & _filename) {
    closeFile();
    filename = _filename;
    loadImage();
}

void EnviFile::closeFile() {
    if(fd != -1) {
        close(fd);
        fd = -1;
    }
    if(data != nullptr) {
        munmap(data, width*height*numFrames*bytesPerPixel);
        data = nullptr;
    }
}

uint16_t *EnviFile::getAvg() {
    if(data == nullptr)
        return NULL;
    unsigned int i, j, avg;
    unsigned int dim = width*height;
    // uint16_t *ret = (uint16_t *)calloc(dim, sizeof(uint16_t));
    uint16_t *ret = new uint16_t[dim]();
    switch(interleave) {
        case Interleave::BIL:
            for(i=0; i<dim; i++) {
                avg = 0;
                for(j=0; j<numFrames; j++)
                    avg+=((uint16_t *)data)[j*dim+i];
                ret[i] = avg/numFrames;
            }
            break;
        default:
            std::cerr << "Interleave type not supported!" << std::endl;
    }
    return ret;
}

// PRIVATE

void EnviFile::parseHeader() {
    std::ifstream hdrStream;
    hdrStream.exceptions(std::ifstream::failbit);
    try {
        std::string line;
        hdrStream.open(filename);
        // check for signature
        std::getline(hdrStream, line);
        if(line.compare(0, 4, "ENVI") !=0)
            std::cerr << filename << " is not an ENVI header file!" << std::endl;

        // read width, height and number of frames
        int ctr=0;
        while(std::getline(hdrStream,line) && ctr < 5) {
            if(line.compare(0, 7, "samples") == 0) {
                auto pos = line.find_last_of(" ");
                width = atoi(line.substr(pos+1).c_str());
                ctr++;
            } else if(line.compare(0, 5, "lines") == 0) {
                auto pos = line.find_last_of(" ");
                numFrames = atoi(line.substr(pos+1).c_str());
                ctr++;
            } else if(line.compare(0, 5, "bands") == 0) {
                auto pos = line.find_last_of(" ");
                height = atoi(line.substr(pos+1).c_str());
                ctr++;
            } else if(line.compare(0, 4, "tint") == 0) {
                                auto pos = line.find_last_of("=");
                                tint = strtod(line.substr(pos+1).c_str(), nullptr);
                                ctr++;
                        } else if(line.compare(0, 3, "fps") == 0) {
                                auto pos = line.find_last_of("=");
                                fps = strtod(line.substr(pos+1).c_str(), nullptr);
                                ctr++;
                        }
        }
        // interleave and bpp are equal for all cameras, so we hardcode it
        interleave = Interleave::BIL;
        bytesPerPixel = 2;
    }
    catch(std::ifstream::failure e) {
        std::cerr << "File " << filename << " not found!" << std::endl;
        std::cerr << "Error: " << e.what() << std::endl;
    }

#ifdef DEBUG
    std::cout << "Width: " << width << std::endl;
    std::cout << "Height: " << height << std::endl;
    std::cout << "numFrames: " << numFrames << std::endl;
#endif // DEBUG

    hdrStream.close();
}

void EnviFile::loadImage() {
    if(filename == "")
        return;

    parseHeader();

    auto dot = filename.find_last_of(".");
    std::string imgFilename = filename.replace(dot+1, 3, "raw");

    // get file size
    struct stat st;
    fd = open(imgFilename.c_str(), O_RDONLY);
    if(fd == -1) {
        perror("open");
        return;
    }
    if(fstat(fd, &st) == -1) {
        perror("fstat");
        return;
    }
    if((unsigned long long)(st.st_size) != (width*height*numFrames*bytesPerPixel)) {
        std::cerr << "Expected filesize: " << width*height*numFrames*bytesPerPixel << "\nActual filesize: " << st.st_size << std::endl;
    }
    data = mmap(NULL, st.st_size, PROT_READ, MAP_SHARED, fd, 0);
}