StatsExtractor.cpp

Go to the documentation of this file.

#include <StatsExtractor.h>
#include <utils.h>
#include <stringtricks.h>

#include <config.h>

#include <climits>      // UINT_MAX
#include <json/json.h>

#include <caltables.inc>

using namespace std;

StatsExtractor::StatsExtractor(zmq::context_t & _ctx,
                                           const PubSubEndpoint & _source,
                                           const PubSubEndpoint & _destination,
                                           const std::string & _identifier) :
        Extractor(_ctx, _source),
        s_identifier(_identifier),
        destination(_destination),
        hdrText(SSTR("ROCS\x01", _identifier, ".hist")),
        hdrBluenessText(SSTR("ROCS\x01", _identifier, ".blueness")){
    histBits = 8;
    if (s_identifier.compare("vnir") == 0) {
        sensorBits = 12;
        blHigh.calData = caltables::vnirHighCal;
        blHigh.roi = {0, 290, caltables::vnirHighCal_spatial_pixels, caltables::vnirHighCal_spectral_pixels};
        blHigh.dark = 270.;
        blHigh.acc = new double[caltables::vnirHighCal_spatial_pixels];
        blLow.calData = caltables::vnirLowCal;
        blLow.roi = {0, 95, caltables::vnirLowCal_spatial_pixels, caltables::vnirLowCal_spectral_pixels};
        blLow.dark = 270.;
        blLow.acc = new double[caltables::vnirHighCal_spatial_pixels];
        haveCalAvg = true;
    } else if (s_identifier.compare("swir") == 0) {
        sensorBits = 14;
        haveCalAvg = false;
    } else {
        sensorBits = 12;
        haveCalAvg = false;
    }
    bitShift = sensorBits - histBits;
    histCount = 1 << histBits;
    bitMask = histCount - 1;
}

StatsExtractor::~StatsExtractor() {
    if(haveCalAvg) {
        delete[] blHigh.acc;
        delete[] blLow.acc;
    }
}

std::string StatsExtractor::type() {
    return "Stats";
}

std::string StatsExtractor::identifier() {
    return s_identifier;
}

std::list<std::string> StatsExtractor::parameters() {
    return {keepGoing?"active":"done"};
}

/****** PRIVATE *****/

void StatsExtractor::extractSetup() {
    // connect to XSUB
    destinationSocket = new zmq::socket_t(ctx, ZMQ_PUB);
    destinationSocket->connect(destination.endpoint.c_str());

    hist = new uint32_t[histCount]();
}

void StatsExtractor::extractImpl(unsigned int _width,
                                       unsigned int _height,
                                       unsigned int _bytesPerPixel,
                                       uint64_t highResTime,
                                       uint64_t wallTime,
                                       zmq::message_t * sourceImage) {
    (void)highResTime;
    (void)wallTime;
    double blueness = 0.;

    min=UINT_MAX, max=0, avg=0;
    memset(hist, 0, histCount*sizeof(uint32_t));

    uint16_t *data = (uint16_t *)sourceImage->data();
    uint16_t *end = data + sourceImage->size()/sizeof(uint16_t);
    for(; data != end; ++data) {
        if((*data)<min) {
            min = *data;
        } else if((*data)>max) {
            max = *data;
        }
        avg += *data;
        ++(hist[((*data)>>bitShift)&bitMask]);
    }
    avg /= (unsigned int)(sourceImage->size()/sizeof(uint16_t));

    /* blueness calculation */
    if(haveCalAvg) {
        data = (uint16_t *)sourceImage->data();
        switch(_bytesPerPixel) {
            case 1:
                blHigh.accumulate<uint8_t>((uint8_t *)sourceImage->data(), _width, _height);
                blLow.accumulate<uint8_t>((uint8_t *)sourceImage->data(), _width, _height);
                break;
            case 2:
                blHigh.accumulate<uint16_t>((uint16_t *)sourceImage->data(), _width, _height);
                blLow.accumulate<uint16_t>((uint16_t *)sourceImage->data(), _width, _height);
                break;
            case 4:
                blHigh.accumulate<uint32_t>((uint32_t *)sourceImage->data(), _width, _height);
                blLow.accumulate<uint32_t>((uint32_t *)sourceImage->data(), _width, _height);
                break;
        }

        blueness = 0.;
        for(unsigned int j = 0; j < blHigh.roi.width; ++j) {
            blueness += blHigh.acc[j] * blHigh.acc[j] / blLow.acc[j];
        }
        blueness /= blHigh.roi.width;
    }

    delete sourceImage;
    // send out status
    sendStatus();
    sendHist();
    if(haveCalAvg) {
        sendBlueness(blueness);
    }
}

void StatsExtractor::extractTeardown() {
    // close XSUB socket
    delete destinationSocket;
    delete[] hist;
}

void StatsExtractor::sendStatus() {
    zmq::message_t msgHdr(11+s_identifier.length());
    char* statusHeaderText = (char*)malloc(12+s_identifier.length());
    snprintf(statusHeaderText, 12+s_identifier.length(), "ROCS\x01%s.stats", s_identifier.c_str());
    memcpy((char*)msgHdr.data(), statusHeaderText, 11+s_identifier.length());
    destinationSocket->send(msgHdr, ZMQ_SNDMORE);
    free(statusHeaderText);

    Json::FastWriter writer;
    Json::Value root;
    root["min"] = min;
    root["max"] = max;
    root["avg"] = avg;
    std::string data = writer.write(root);
    zmq::message_t msgData(data.length());
    memcpy((char *)msgData.data(), data.c_str(), data.length());
    destinationSocket->send(msgData);
}

void StatsExtractor::sendHist() {
    zmq::message_t msgHdr(hdrText.length());
    memcpy((char*)msgHdr.data(), hdrText.c_str(), hdrText.length());
    destinationSocket->send(msgHdr, ZMQ_SNDMORE);

    Json::FastWriter writer;
    Json::Value root;
    for(uint32_t i=0; i<histCount; i++) {
        root.append(hist[i]);
    }
    std::string data = writer.write(root);
    zmq::message_t msgData(data.length());
    memcpy((char *)msgData.data(), data.c_str(), data.length());
    destinationSocket->send(msgData);
}

void StatsExtractor::sendBlueness(double blueness) {
    zmq::message_t msgHdr(hdrBluenessText.length());
    memcpy((char*)msgHdr.data(), hdrBluenessText.c_str(), hdrBluenessText.length());
    destinationSocket->send(msgHdr, ZMQ_SNDMORE);

    Json::FastWriter writer;
    Json::Value root;
    if(blueness != blueness) {
        root = Json::Value::null;
    } else {
        root = blueness;
    }
    std::string data = writer.write(root);
    zmq::message_t msgData(data.length());
    memcpy((char *)msgData.data(), data.c_str(), data.length());
    destinationSocket->send(msgData);
}


template <typename T> void StatsExtractor::CalAvgData::accumulate(T* data, unsigned int w, unsigned int h) {
    (void)h;
    double temp;
    for(unsigned int j = 0; j < roi.width; ++j) {
        acc[j] = 0.;
    }
    for(unsigned int i = 0; i < roi.height; ++i) {
        for(unsigned int j = 0; j < roi.width; ++j) {
            temp = data[(i + roi.y) * w + j + roi.x] - dark;
            if(temp < 0.) {
                temp = 0;
            }
            acc[j] +=  temp * calData[i * roi.width + j];
        }
    }
}