PortableBitmapReader.cpp

Go to the documentation of this file.

#include "Utilities/PortableBitmapReader.h"
 
#include <fstream>
#include <iomanip>
#include <iostream>
#include <sstream>
 
PortableBitmapReader::PortableBitmapReader(const std::string& input) {
    std::ifstream in(input);
    readHeader(in);
    pixels_m.resize(width_m * height_m);
 
    if (type_m == ASCII) {
        readImageAscii(in);
    } else {
        readImageBinary(in);
    }
}
 
std::string PortableBitmapReader::getNextPart(std::istream& in) {
    do {
        char c = in.get();
        if (c == '#') {
            do {
                c = in.get();
            } while (c != '\n');
        } else if (!(c == ' ' || c == '\t' || c == '\n' || c == '\r')) {
            in.putback(c);
            break;
        }
    } while (true);
 
    std::string nextPart;
    in >> nextPart;
 
    return nextPart;
}
 
void PortableBitmapReader::readHeader(std::istream& in) {
    std::string magicValue = getNextPart(in);
 
    if (magicValue == "P1") {
        type_m = ASCII;
    } else if (magicValue == "P4") {
        type_m = BINARY;
    } else {
        throw OpalException(
                "PortableBitmapReader::readHeader", "Unknown magic value: '" + magicValue + "'");
    }
 
    {
        std::string tmp = getNextPart(in);
        std::istringstream conv;
        conv.str(tmp);
        conv >> width_m;
    }
 
    {
        std::string tmp = getNextPart(in);
        std::istringstream conv;
        conv.str(tmp);
        conv >> height_m;
    }
 
    char tmp;
    in.read(&tmp, 1);
}
 
void PortableBitmapReader::readImageAscii(std::istream& in) {
    unsigned int size = height_m * width_m;
    unsigned int i    = 0;
    while (i < size) {
        char c;
        in >> c;
 
        if (!(c == ' ' || c == '\n' || c == '\t' || c == '\r')) {
            pixels_m[i] = (c == '1');
            ++i;
        }
    }
}
 
void PortableBitmapReader::readImageBinary(std::istream& in) {
    static const unsigned int sizeChar = sizeof(char) * 8;
 
    unsigned int numPixels = 0;
    unsigned char c        = 0;
    for (unsigned int row = 0; row < height_m; ++row) {
        for (unsigned int col = 0; col < width_m; ++col) {
            if (col % sizeChar == 0) {
                char c2 = 0;
                in.read(&c2, 1);
                c = (unsigned char)c2;
            }
            unsigned int k      = sizeChar - 1 - (col % sizeChar);
            pixels_m[numPixels] = (c >> k & 1);
            ++numPixels;
        }
    }
}
 
void PortableBitmapReader::print(std::ostream& /*out*/) const {
    for (unsigned int i = 0; i < height_m; ++i) {
        for (unsigned int j = 0; j < width_m; ++j) {
            if (j % 8 == 0) {
                unsigned int byte = 0;
                for (unsigned int k = 0; k < 8 && j + k < width_m; ++k) {
                    unsigned int idx = getIdx(i, j + k);
                    if (pixels_m[idx]) byte = byte | (1 << (7 - k));
                }
                std::cout << "  " << std::hex << std::setw(2) << std::setfill('0') << byte << ": ";
            }
            unsigned int idx = getIdx(i, j);
            std::cout << pixels_m[idx];
        }
        std::cout << std::endl;
    }
}