imagepair.h

/*******************************************************************************
 * Copyright (c) 2018 Nerian Vision GmbH
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *******************************************************************************/

#ifndef VISIONTRANSFER_IMAGEPAIR_H
#define VISIONTRANSFER_IMAGEPAIR_H

#include <cassert>
#include <cstddef>
#include "visiontransfer/common.h"

class VT_EXPORT ImagePair {
public:
    enum ImageFormat {
        FORMAT_8_BIT_MONO,

        FORMAT_8_BIT_RGB,

        FORMAT_12_BIT_MONO
    };

    enum ImageFormat_Deprecated {
        FORMAT_8_BIT = ImageFormat::FORMAT_8_BIT_MONO,
        FORMAT_12_BIT = ImageFormat::FORMAT_12_BIT_MONO
    };

    ImagePair();

    ImagePair(const ImagePair& other);

    ~ImagePair();
    ImagePair& operator= (ImagePair const& other);

    void setWidth(int w) {width = w;}

    void setHeight(int h) {height = h;}

    void setRowStride(int imageNumber, int stride) {
        assert(imageNumber >= 0 && imageNumber <=1);
        rowStride[imageNumber] = stride;
    }

    void setPixelFormat(int imageNumber, ImageFormat format) {
        assert(imageNumber >= 0 && imageNumber <=1);
        formats[imageNumber] = format;
    }

#ifndef DOXYGEN_SHOULD_SKIP_THIS
    DEPRECATED(void setPixelFormat(int imageNumber, ImageFormat_Deprecated format)) {
        setPixelFormat(imageNumber, static_cast<ImageFormat>(format));
    }
#endif

    void setPixelData(int imageNumber, unsigned char* pixelData) {
        assert(imageNumber >= 0 && imageNumber <=1);
        data[imageNumber] = pixelData;
    }

    void setQMatrix(const float* q) {
        qMatrix = q;
    }

    void setSequenceNumber(unsigned int num) {
        seqNum = num;
    }

    void setTimestamp(int seconds, int microsec) {
        timeSec = seconds;
        timeMicrosec = microsec;
    }

    void setDisparityRange(int minimum, int maximum) {
        minDisparity = minimum;
        maxDisparity = maximum;
    }

    void setImageDisparityPair(bool dispPair) {
        disparityPair = dispPair;
    }

    int getWidth() const {return width;}

    int getHeight() const {return height;}

    int getRowStride(int imageNumber) const {
        assert(imageNumber >= 0 && imageNumber <=1);
        return rowStride[imageNumber];
    }

    ImageFormat getPixelFormat(int imageNumber) const {
        assert(imageNumber >= 0 && imageNumber <=1);
        return formats[imageNumber];
    }

    unsigned char* getPixelData(int imageNumber) const {
        assert(imageNumber >= 0 && imageNumber <=1);
        return data[imageNumber];
    }

    const float* getQMatrix() const {
        return qMatrix;
    }

    unsigned int getSequenceNumber() const {return seqNum;}

    void getTimestamp(int& seconds, int& microsec) const {
        seconds = timeSec;
        microsec = timeMicrosec;
    }

    void getDisparityRange(int& minimum, int& maximum) const {
        minimum = minDisparity;
        maximum = maxDisparity;
    }

    void writePgmFile(int imageNumber, const char* fileName) const;

    bool isImageDisparityPair() const {
        return disparityPair;
    }

    void copyTo(ImagePair& dest);

    int getBytesPerPixel(int imageNumber) const {
        assert(imageNumber >= 0 && imageNumber <=1);
        return getBytesPerPixel(formats[imageNumber]);
    }

    static int getBytesPerPixel(ImageFormat format);

private:
    // No pimpl idiom here as almost everything is inlined.

    int width;
    int height;
    int rowStride[2];
    ImageFormat formats[2];
    unsigned char* data[2];
    const float* qMatrix;
    int timeSec;
    int timeMicrosec;
    unsigned int seqNum;
    int minDisparity;
    int maxDisparity;
    bool disparityPair;
    int* referenceCounter;

    void copyData(ImagePair& dest, const ImagePair& src, bool countRef);
    void decrementReference();
};

#endif