semanticsegmentation.h

#ifndef NTHFRAME_H
#define NTHFRAME_H
 
#include <QObject>
#include <QString>
#include <QTimer>
#include <QDir>
#include <QException>
#include <QCoreApplication>
#include <QThread>
#include <QMutex>
#include <QMutexLocker>
#include <QTranslator>
 
#include <QDebug>
 
#include "semanticsegmentation_global.h"
#include "itransform.h"
#include "settingswidget.h"
 
#include <iostream>
#include <fstream>
 
#include <opencv2/opencv.hpp>
#include <opencv2/core/ocl.hpp>
 
#include <iostream>
#include <iomanip>
#include <regex>
 
#include <NeuralNetFactory.h>
#include <Tensor.h>
#include <NeuralUtil.h>
 
#define MODEL_PATH "/plugins/resources/neural_network_models"
#define HW_NAME(x) x ? "Using GPU (cuda)" : "Using CPU"
#define USED_MODEL "Used Model"
#define SELECTED_CLASSES "Selected classes"
 
class SEMANTICSEGMENTATION_EXPORT SemanticSegmentation : public ITransform
{
    Q_OBJECT
    Q_PLUGIN_METADATA(IID "iVS3D.ITransform")   // implement interface as plugin, use the iid as identifier
    Q_INTERFACES(ITransform)                        // declare this as implementation of ITransform interface
 
public:
    SemanticSegmentation();
    ~SemanticSegmentation();
 
    QWidget* getSettingsWidget(QWidget *parent) override;
 
    QString getName() const override;
 
    ITransform *copy() override;
 
    TransformResult transform(uint idx, const cv::Mat &img, const Resolution &resolution, const ROI &roi) override;
 
    void enableCuda(bool enabled) override;
 
    void setSettings(QMap<QString, QVariant> settings) override;
 
    QMap<QString, QVariant> getSettings() override;
 
    void deactivate() override;
 
signals:
    void sig_classesAndColorsChanged(QStringList classes, QColorList colors, QBoolList selectedClasses);
 
    void sig_message(QString processor, QString message = "", bool active = true);
 
    void sig_error(QString message);
 
private slots:
    // --- slots for signals from SettingsWidget ---
    void slot_ONNXindexChanged(int n);
    void slot_selectedClassesChanged(QBoolList classes);
    void slot_blendAlphaChanged(float alpha);
 
private:
    struct ClassInfo
    {
        QString name; // Name of the class
        QColor color; // Color for the class in the semantic map
    };
 
    struct ModelInfo
    {
        std::vector<float> mean, std;   // Mean and standard deviation for normalization
        std::vector<ClassInfo> classes; // Classes with their colors for the model
    } m_modelInfo;
 
    bool loadModelInfo();
 
    // --- gui data
    SettingsWidget *m_settingsWidget;   // settings widget for this ITransform
    float m_blendAlpha;                 // alpha for semantic map overlay
    bool m_guiUpToDate;                 // is true if gui is up to date, used to avoid unnessecary updates
    void sendGuiPreview();
 
    // --- ONNX model data ---
    QStringList m_ONNXmodelList;    // model names
    NN::NeuralNetPtr m_model;       // active model
    int m_ONNXmodelIdx;             // index of selected model in m_ONNXmodelList
    QBoolList m_ONNXselectedClasses;// bool for each class of selected model (true if class selected)
 
    // --- Buffer for image, nn score, segmentation and mask ---
    uint m_imageIdx;
    cv::Mat m_originalImage;
    cv::Mat m_image;
    Resolution m_resolution;
    ROI m_roi;
    NN::Tensor m_segmentationClasses;
    cv::Mat m_segmentationColorized;
    cv::Mat m_segmentationMask;
    // --- use CUDA acceleration ---
    bool m_useCuda;
    // --- Widget sync ---
    bool m_updateClasses = true;       //Disable updates if classes are set manuel
    
    // --- blend two images using an alpha value ---
    void alphaBlend(const cv::Mat &foreground,const cv::Mat &background, cv::Mat &destionation, float alpha);
 
    bool computeColorization();
    bool computeMask();
 
    Error createError(const QString &message);
    QMutex m_mutex;
};
 
#endif // NTHFRAME_H