preprocessor/preprocessing.h at master · pvavercak/preprocessor · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
#ifndef PREPROCESSING_H
#define PREPROCESSING_H
#define _USE_MATH_DEFINES

#include "preprocessing_global.h"
#include "preprocessing_config.h"

#include "orientationmap.h"
#include "gaborfiltermultithread.h"
#include "gaborfiltergpu.h"
#include "binarization.h"
#include "contrastenhancement.h"
#include "thinning.h"
#include "frequencymap.h"
#include "mask.h"
#include "qualitymap.h"

typedef struct preprocessing_all_results {
    cv::Mat imgOriginal;
    cv::Mat imgContrastEnhanced;
    cv::Mat imgEnhanced; // obrazok po prefiltrovani
    cv::Mat imgOrientationMap; // obrazok smerovej mapy
    cv::Mat imgBinarized;
    cv::Mat imgSkeleton;
    cv::Mat imgSkeletonInverted;
    cv::Mat imgMask;
    cv::Mat imgFrequencyMap;
    cv::Mat imgQualityMap;
    cv::Mat frequencyMap;
    cv::Mat orientationMap;
    cv::Mat qualityMap;
    qintptr requester;
} PREPROCESSING_ALL_RESULTS;

#ifndef PREPROCESSING_RESULTS_DEFINED
typedef struct preprocessing_results {
    cv::Mat imgOriginal;
    cv::Mat imgSkeleton;
    cv::Mat imgSkeletonInverted;
    cv::Mat qualityMap;
    cv::Mat orientationMap;
    qintptr requester;
} PREPROCESSING_RESULTS;
#define PREPROCESSING_RESULTS_DEFINED
#endif

//duration in ms
typedef struct preprocessing_durations {
    int contrastEnhancement;
    float orientationMap;
    float gaborFilter;
    int binarization;
    int removingHoles;
    int thinning;
    int mask;
    int qualityMap;
    int frequencyMap;
} PREPROCESSING_DURATIONS;

class PREPROCESSINGSHARED_EXPORT Preprocessing : public QObject
{
    Q_OBJECT

public:
    Preprocessing();
    void start();

    int loadInput(cv::Mat imgOriginal, const qintptr& requester);
    int loadInput(QVector<cv::Mat> imgOriginals, const qintptr& requester);
    int loadInput(QString inputPath, const qintptr& requester);

    int setPreprocessingParams(int blockSize = 13, double gaborLambda = 9, double gaborSigma = 3, int gaussBlockBasic = 1, double gaussSigmaBasic = 1.0, int gaussBlockAdvanced = 121, double gaussSigmaAdvanced = 10.0, int holeSize = 20);
    int setFeatures(bool useAdvancedMode, bool useContrastEnhancement = true, bool useAdvancedOrientationMap = true, bool useHoleRemover = true, bool generateInvertedSkeleton = true, bool useQualityMap = true, bool useMask = false, bool useFrequencyMap = false);
    int setFrequencyMapParams(CAFFE_FILES freqFiles, int blockSize, int exBlockSize);
    int setMaskParams(CAFFE_FILES maskFiles, int blockSize, int exBlockSize, bool useSmooth);
    int setCPUOnly(bool enabled, int threadNum = 0);

private:
    ContrastEnhancement contrast;
    OrientationMap oMap;
    QualityMap qMap;
    GaborFilterMultiThread gaborMultiThread; // objekt na paralelne filtrovanie odtlacku
    GaborFilterGPU gaborGPU;
    Binarization binarization;
    Thinning thinning;
    Mask mask;
    FrequencyMap fMap;
    qintptr requester;

    QTime timer;

    bool preprocessingIsRunning;

    // INPUT
    INPUT_PARAMS inputParams;

    // PARAMS
    OMAP_PARAMS omapParams;
    QMAP_PARAMS qmapParams;
    FMAP_PARAMS fmapParams;
    MASK_PARAMS maskParams;
    CONTRAST_PARAMS contrastParams;
    GABOR_PARAMS gaborParams;
    BINARIZATION_PARAMS binarizationParams;

    PREPROCESSING_FEATURES features;
    PREPROCESSING_GENERAL general;

    // OUTPUT
    af::array orientationMapAF;
    PREPROCESSING_ALL_RESULTS results;
    QMap<QString, PREPROCESSING_RESULTS> resultsMap;
    QMap<QString, PREPROCESSING_ALL_RESULTS> allResultsMap;

    PREPROCESSING_DURATIONS durations;

    // PRIVATE FUNCTIONS
    void continueAfterGabor();
    void preprocessingError(int errorcode);
    void cleanResults();
    void cleanInput();
    void cleanDurations();
    void startProcess(const cv::Mat &imgOriginal);

private slots:
    void allGaborThreadsFinished();

signals:
    void preprocessingDoneSignal(PREPROCESSING_ALL_RESULTS results);
    void preprocessingDoneSignal(PREPROCESSING_RESULTS results);

    void preprocessingSequenceDoneSignal(QMap<QString, PREPROCESSING_ALL_RESULTS> results);
    void preprocessingSequenceDoneSignal(QMap<QString, PREPROCESSING_RESULTS> results);

    void preprocessingDurationSignal(PREPROCESSING_DURATIONS durations);
    void preprocessingProgressSignal(int progress);
    void preprocessingErrorSignal(int errorcode);
};

#endif // PREPROCESSING_H