imageset.h

/*******************************************************************************
 * Copyright (c) 2023 Allied Vision Technologies 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_IMAGESET_H
#define VISIONTRANSFER_IMAGESET_H
 
#include <cassert>
#include <cstddef>
#include "visiontransfer/common.h"
 
namespace visiontransfer {
 
class VT_EXPORT ImageSet {
public:
    static const int MAX_SUPPORTED_IMAGES = 4;
    enum ImageFormat {
        FORMAT_8_BIT_MONO,
 
        FORMAT_8_BIT_RGB,
 
        FORMAT_12_BIT_MONO
    };
 
    enum ImageFormat_Deprecated {
        FORMAT_8_BIT =  FORMAT_8_BIT_MONO,
        FORMAT_12_BIT = FORMAT_12_BIT_MONO
    };
 
    enum ImageType {
        IMAGE_UNDEFINED,
        IMAGE_LEFT,
        IMAGE_DISPARITY,
        IMAGE_RIGHT,
 
        IMAGE_COLOR
    };
 
    ImageSet();
 
    ImageSet(const ImageSet& other);
 
    ~ImageSet();
    ImageSet& operator= (ImageSet const& other);
 
    void setWidth(int w) {width = w;}
 
    void setHeight(int h) {height = h;}
 
    void setRowStride(int imageNumber, int stride) {
        assert(imageNumber >= 0 && imageNumber < getNumberOfImages());
        rowStride[imageNumber] = stride;
    }
 
    void setPixelFormat(int imageNumber, ImageFormat format) {
        assert(imageNumber >= 0 && imageNumber < getNumberOfImages());
        formats[imageNumber] = format;
    }
 
#ifndef DOXYGEN_SHOULD_SKIP_THIS
    DEPRECATED("Use setPixelFormat(int, ImageFormat) instead") 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 < getNumberOfImages());
        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 setSubpixelFactor(int subpixFact) {
        subpixelFactor = subpixFact;
    }
 
#ifndef DOXYGEN_SHOULD_SKIP_THIS
 
    DEPRECATED("Only compatible with two-image sets: use setNumberOfImages() and setIndexOf() instead")
    void setImageDisparityPair(bool dispPair);
#endif
 
    int getWidth() const {return width;}
 
    int getHeight() const {return height;}
 
    int getRowStride(int imageNumber) const {
        assert(imageNumber >= 0 && imageNumber < getNumberOfImages());
        return rowStride[imageNumber];
    }
 
    int getRowStride(ImageType what) const {
        int idx = getIndexOf(what, true);
        return getRowStride(idx);
    }
 
    ImageFormat getPixelFormat(int imageNumber) const {
        assert(imageNumber >= 0 && imageNumber < getNumberOfImages());
        return formats[imageNumber];
    }
 
    ImageFormat getPixelFormat(ImageType what) const {
        int idx = getIndexOf(what, true);
        return getPixelFormat(idx);
    }
 
    unsigned char* getPixelData(int imageNumber) const {
        assert(imageNumber >= 0 && imageNumber < getNumberOfImages());
        return data[imageNumber];
    }
 
    unsigned char* getPixelData(ImageType what) const {
        int idx = getIndexOf(what, true);
        return getPixelData(idx);
    }
 
    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;
    }
 
    int getSubpixelFactor() const {
        return subpixelFactor;
    }
 
    void writePgmFile(int imageNumber, const char* fileName) const;
 
#ifndef DOXYGEN_SHOULD_SKIP_THIS
 
    DEPRECATED("Only compatible with two-image sets: use hasImageType(ImageSet::IMAGE_DISPARITY) instead")
    bool isImageDisparityPair() const {
        return (getNumberOfImages()==2) && hasImageType(IMAGE_DISPARITY);
    }
#endif
 
    void copyTo(ImageSet& dest);
 
    int getBytesPerPixel(int imageNumber) const {
        assert(imageNumber >= 0 && imageNumber < getNumberOfImages());
        return getBytesPerPixel(formats[imageNumber]);
    }
 
    int getBitsPerPixel(int imageNumber) const {
        assert(imageNumber >= 0 && imageNumber < getNumberOfImages());
        return getBitsPerPixel(formats[imageNumber]);
    }
 
    int getBitsPerPixel(ImageType what) const {
        int idx = getIndexOf(what, true);
        return getBitsPerPixel(idx);
    }
 
    static int getBitsPerPixel(ImageFormat format);
 
    static int getBytesPerPixel(ImageFormat format);
 
    int getNumberOfImages() const {
        return numberOfImages;
    }
 
    void setNumberOfImages(int number) {
        assert(number >= 1 && number <= MAX_SUPPORTED_IMAGES);
        numberOfImages = number;
    }
 
    ImageType getImageType(int imageNumber) const;
 
    int getIndexOf(ImageType what, bool throwIfNotFound=false) const;
 
    bool hasImageType(ImageType what) const {
        return getIndexOf(what) >= 0;
    }
 
 
    void setIndexOf(ImageType what, int idx);
 
 
#ifdef CV_MAJOR_VERSION
 
    inline void toOpenCVImage(int imageNumber, cv::Mat& dest, bool convertRgbToBgr = true);
#endif
 
    void setExposureTime(int timeMicrosec) {
        exposureTime = timeMicrosec;
    }
 
    int getExposureTime() const {
        return exposureTime;
    }
 
    void setLastSyncPulse(int seconds, int microsec) {
        lastSyncPulseSec = seconds;
        lastSyncPulseMicrosec = microsec;
    }
 
    void getLastSyncPulse(int& seconds, int& microsec) const {
        seconds = lastSyncPulseSec;
        microsec = lastSyncPulseMicrosec;
    }
 
private:
    // No pimpl idiom here as almost everything is inlined.
    int width;
    int height;
    int rowStride[MAX_SUPPORTED_IMAGES];
    ImageFormat formats[MAX_SUPPORTED_IMAGES];
    unsigned char* data[MAX_SUPPORTED_IMAGES];
    const float* qMatrix;
    int timeSec;
    int timeMicrosec;
    unsigned int seqNum;
    int minDisparity;
    int maxDisparity;
    int subpixelFactor;
    int* referenceCounter;
    int numberOfImages;
 
    int indexLeftImage;
    int indexRightImage;
    int indexDisparityImage;
    int indexColorImage;
 
    int exposureTime;
    int lastSyncPulseSec;
    int lastSyncPulseMicrosec;
 
    void copyData(ImageSet& dest, const ImageSet& src, bool countRef);
    void decrementReference();
};
 
#ifndef DOXYGEN_SHOULD_SKIP_THIS
// For source compatibility
class DEPRECATED("Use ImageSet instead.") ImagePair: public ImageSet {
};
#endif
 
} // namespace
 
#include "visiontransfer/imageset-opencv.h"
#endif