2018: Auto stash before merge of "dev2018" and "origin/dev2018"

app/Operations/DoubleEntropyOp.cpp

@@ -40,7 +40,11 @@ void DoubleEntropyOp::operator()(const Image_t<double>* image, const std::map<co
 
     double entropy = image->getEntropy();
     outText(qApp->translate("Operations", "Entropy of the image (sum of channels entropy) = %1\n").arg(entropy).toStdString());
+<<<<<<< Updated upstream
     outText(qApp->translate("Operations", "Pas d'échantillonnage choisi : 1\n").toStdString());
+=======
+ //   outText(qApp->translate("Pas d'échantillonnage choisi : 1\n"));
+>>>>>>> Stashed changes
 }
 
 bool DoubleEntropyOp::needCurrentImg() const {

app/Operations/ThresholdOp.cpp

@@ -16,7 +16,6 @@ bool ThresholdOp::needCurrentImg() const {
 }
 
 void ThresholdOp::operator()(const imagein::Image* image, const std::map<const imagein::Image*, std::string>&) {
-    
     const GrayscaleImage* img = dynamic_cast<const GrayscaleImage*>(image);
     bool convert = (img == NULL);
     if(convert) {

app/Services/FilteringService.h

@@ -24,8 +24,8 @@
 
 #include <Widgets/ImageWidgets/StandardImageWindow.h>
 
-#include "Widgets/FilterChoice.h"
-#include "Widgets/FilterEditor.h"
+#include "../Widgets/FilterChoice.h"
+#include "../Widgets/FilterEditor.h"
 
 #include <QStringList>
 #ifdef __linux__

infos_complementaires.md

@@ -4,7 +4,7 @@
 
 *ImageINSA* se compose de 4 modules de compilation:
  1. *ImageIn*, librairie de traitement d'images
- 2. *GenericInterface*, interface graphitque pour manipuler les images
+ 2. *GenericInterface*, interface graphique pour manipuler les images
  3. *core*, librairie principale fournissant le coeur de métier de *ImageINSA*
  4. *ImageINSA*, executable final
 
@@ -30,4 +30,4 @@ Voir les commits 86db68e9ffae de eiimage et 9ba87b46e de Detiq-T
 ## Autres solutions possibles
 
  - Faire en sorte que tous les modules soient des librairies dynamiques
- - Réarchtecturer *ImageINSA* et refaire un découpage dont la logique suit les relations de dépendances entre les modules plutôt que l'historique du logiciel.
\ No newline at end of file
+ - Réarchtecturer *ImageINSA* et refaire un découpage dont la logique suit les relations de dépendances entre les modules plutôt que l'historique du logiciel.

test/README.txt

+In order to launch the test class you need to follow these steps:
+	-First of all compile the project with CMAKE (or whatever compiler you're using) in your build directory, then build the .exe with make.
+	-Then go back to this directory and use qmake --project.
+	-qmake
+	-make
+
+You will probably have to edit the .pro file before the qmake in order to specify the path to the qwt library in the include path (e.g /mydirectory/qwt6.0.1/src), and to specify the .a used by the test class to run the tests by adding the line "LIBS += -L../build/ImageINSA/lib llibimageinsa" to the .pro file.

test/testgui.cpp

+#include <QtWidgets>
+#include <QtTest/QtTest>
+#include <QString>
+#include <GenericInterface.h>
+
+#include "../lib/detiq-t/GenericInterface/Widgets/ImageWidgets/StandardImageWindow.h"
+
+#include "../core/BuiltinOpSet.h"
+#include "../core/Operation.h"
+
+#include "../app/Services/MorphoMatService.h"
+#include "../app/Services/FilteringService.h"
+#include "../app/Services/PluginManager.h"
+#include "../app/Services/ImageINSAService.h"
+
+#include "../app/Operations/PointOp.h"
+#include "../app/Operations/ThresholdOp.h"
+#include "../app/Operations/TranslateOp.h"
+#include "../app/Operations/RotateOp.h"
+#include "../app/Operations/FlipOp.h"
+#include "../app/Operations/CenterOp.h"
+#include "../app/Operations/SplitColorOp.h"
+#include "../app/Operations/SplitHsvOp.h"
+#include "../app/Operations/CombineColorOp.h"
+#include "../app/Operations/CombineHsvOp.h"
+#include "../app/Operations/SignalToNoiseOp.h"
+#include "../app/Operations/MeanSquaredErrorOp.h"
+#include "../app/Operations/FFTOp.h"
+#include "../app/Operations/IFFTOp.h"
+#include "../app/Operations/RandomImgOp.h"
+#include "../app/Operations/NoiseOp.h"
+#include "../app/Operations/BFlitOp.h"
+#include "../app/Operations/DMMOp.h"
+#include "../app/Operations/PseudoColorOp.h"
+#include "../app/Operations/CroissanceOp.h"
+#include "../app/Operations/ZeroCrossingOp.h"
+#include "../app/Operations/HistogramOp.h"
+#include "../app/Operations/ColorimetryOp.h"
+#include "../app/Operations/SinusSynthesisOp.h"
+#include "../app/Operations/ScalingOp.h"
+#include "../app/Operations/QuantificationOp.h"
+#include "../app/Operations/DoubleEntropyOp.h"
+#include "../app/Operations/EntropyOp.h"
+#include "../app/Operations/HuffmanOp.h"
+#include "../app/Operations/RejectionRingOp.h"
+#include "../app/Operations/DPCMEncodingOp.h"
+#include "../app/Operations/HadamardOp.h"
+#include "../app/Operations/DCTOp.h"
+#include "../app/Operations/HoughOp.h"
+#include "../app/Operations/InverseHoughOp.h"
+#include "../app/Operations/PyramidOp.h"
+#include "../app/Operations/InversePyramidOp.h"
+#include "../app/Operations/ClassAnalysisOp.h"
+#include "../app/Operations/ClassResultOp.h"
+#include "../app/Operations/SeparatorOp.h"
+#include "../app/Operations/MedianOp.h"
+#include "../app/Operations/UCharConvertOp.h"
+
+using namespace imagein;
+using namespace genericinterface;
+
+class TestGui: public QObject
+{
+    Q_OBJECT
+
+private:
+    GenericInterface* gi;
+    StandardImageWindow* _img;
+
+private slots:
+    void testGenericInterfaceSetup();
+    void testWindowServiceAddFile();
+    void testFileServiceSave();
+    void testRemoveImage();
+    void testThresholdOp();
+};
+
+
+void TestGui::testGenericInterfaceSetup(){
+      gi = new GenericInterface ("ImageInsa", Qt::LeftDockWidgetArea);
+      PluginManager* pluginManager = new PluginManager(gi);
+      ImageINSAService* mainService = new ImageINSAService(gi);
+
+      BuiltinOpSet* image = new BuiltinOpSet(qApp->translate("", "&Image").toStdString());
+      image->addOperation(new PointOp());
+      image->addOperation(new TranslateOp());
+      image->addOperation(new RotateOp());
+      image->addOperation(new CenterOp());
+      image->addOperation(new FlipOp(FlipOp::Horizontal));
+      image->addOperation(new FlipOp(FlipOp::Vertical));
+      image->addOperation(new SeparatorOp());
+      image->addOperation(new SplitColorOp());
+      image->addOperation(new SplitHsvOp());
+      image->addOperation(new CombineColorOp());
+      image->addOperation(new CombineHSVOp());
+      image->addOperation(new SeparatorOp());
+      image->addOperation(new ScalingOp());
+      image->addOperation(new QuantificationOp());
+      image->addOperation(new ThresholdOp());
+      image->addOperation(new HistogramOp());
+      image->addOperation(new SeparatorOp());
+      image->addOperation(new UCharConvertOp());
+
+      BuiltinOpSet* tools = new BuiltinOpSet(qApp->translate("", "&Tools").toStdString());
+
+      tools->addOperation(new SignalToNoiseOp());
+      tools->addOperation(new MeanSquaredErrorOp());
+      tools->addOperation(new DoubleEntropyOp());
+      tools->addOperation(new EntropyOp());
+      tools->addOperation(new NoiseOp());
+      tools->addOperation(new SeparatorOp());
+      tools->addOperation(new RandomImgOp());
+      tools->addOperation(new ColorimetryOp());
+      tools->addOperation(new RejectionRingOp());
+      tools->addOperation(new SinusSynthesisOp());
+
+      BuiltinOpSet* encode = new BuiltinOpSet(qApp->translate("", "&Encoding").toStdString());
+      encode->addOperation(new HuffmanOp());
+      encode->addOperation(new DPCMEncodingOp());
+
+      BuiltinOpSet* morpho = new BuiltinOpSet("&Morpho. math.");
+      morpho->addOperation(new DMMOp());
+      morpho->addOperation(new SeparatorOp());
+
+      BuiltinOpSet* transfo = new BuiltinOpSet(qApp->translate("", "Transforms").toStdString());
+      transfo->addOperation(new FFTOp());
+      transfo->addOperation(new IFFTOp());
+      transfo->addOperation(new HadamardOp());
+      transfo->addOperation(new DCTOp());
+      transfo->addOperation(new HoughOp());
+      transfo->addOperation(new InverseHoughOp());
+
+      BuiltinOpSet* analyse = new BuiltinOpSet(qApp->translate("", "Analysis").toStdString());
+      analyse->addOperation(new CroissanceOp());
+      analyse->addOperation(new ZeroCrossingOp());
+      analyse->addOperation(new PyramidOp());
+      analyse->addOperation(new InversePyramidOp());
+      analyse->addOperation(new ClassAnalysisOp());
+      analyse->addOperation(new ClassResultOp());
+      analyse->addOperation(new PseudoColorOp());
+
+      BuiltinOpSet* filter = new BuiltinOpSet(qApp->translate("", "Filtering").toStdString());
+      filter->addOperation(new BFlitOp());
+      filter->addOperation(new MedianOp());
+
+      mainService->addOpSet(image);
+      mainService->addOpSet(encode);
+      mainService->addOpSet(morpho);
+      mainService->addOpSet(analyse);
+      mainService->addOpSet(transfo);
+      mainService->addOpSet(filter);
+      mainService->addOpSet(tools);
+
+      gi->addService(new MorphoMatService);
+      gi->addService(new filtrme::FilteringService);
+      gi->addService(pluginManager);
+      gi->run();
+}
+
+void TestGui::testWindowServiceAddFile() {
+  WindowService* ws = dynamic_cast<WindowService*>(gi->getService(GenericInterface::WINDOW_SERVICE));
+  ws->addFile(QString("test.jpg"));
+  _img = dynamic_cast<StandardImageWindow*>(ws->getCurrentImageWindow());
+  /* I have a doubt on the usefulness of the following test.
+   *Is void casting really relevant when comparing values ?
+   */
+  QVERIFY((void*)_img != (void*)0);
+  QCOMPARE(ws->getCurrentImageWindow()->getPath(),QString("test.jpg"));
+}
+
+void TestGui::testFileServiceSave() {
+  FileService* fs = dynamic_cast<FileService*>(gi->getService(GenericInterface::FILE_SERVICE));
+  fs->save("tata.jpg");
+
+  Image test("test.jpg"), tata("tata.jpg");
+
+  QCOMPARE(test.getWidth(),      tata.getWidth());
+  QCOMPARE(test.getHeight(),     tata.getHeight());
+  QCOMPARE(test.getNbChannels(), tata.getNbChannels());
+}
+
+void TestGui::testRemoveImage() {
+  QFile("tata.jpg").remove();
+  QString sbempty = QFINDTESTDATA("tata.jpg");
+  QCOMPARE(sbempty, QString(""));
+}
+
+void TestGui::testThresholdOp(){
+    WindowService* ws = dynamic_cast<WindowService*>(gi->getService(GenericInterface::WINDOW_SERVICE));
+    ws->addFile(QString("test.jpg"));
+
+    QMenu* imagemenu = gi->menu("&Image");
+
+    QList<QAction*> list = imagemenu->actions();
+    for( int i=0; i<list.count(); ++i )
+    {
+        std::cout << list[i]->text().toStdString() << "\n";
+        list[i]->trigger();
+        std::cout << i << " passed\n";
+    }
+}
+
+QTEST_MAIN(TestGui)
+#include "testgui.moc"

test/testgui.moc

+/****************************************************************************
+** Meta object code from reading C++ file 'testgui.cpp'
+**
+** Created by: The Qt Meta Object Compiler version 67 (Qt 5.5.1)
+**
+** WARNING! All changes made in this file will be lost!
+*****************************************************************************/
+
+#include <QtCore/qbytearray.h>
+#include <QtCore/qmetatype.h>
+#if !defined(Q_MOC_OUTPUT_REVISION)
+#error "The header file 'testgui.cpp' doesn't include <QObject>."
+#elif Q_MOC_OUTPUT_REVISION != 67
+#error "This file was generated using the moc from 5.5.1. It"
+#error "cannot be used with the include files from this version of Qt."
+#error "(The moc has changed too much.)"
+#endif
+
+QT_BEGIN_MOC_NAMESPACE
+struct qt_meta_stringdata_TestGui_t {
+    QByteArrayData data[7];
+    char stringdata0[112];
+};
+#define QT_MOC_LITERAL(idx, ofs, len) \
+    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
+    qptrdiff(offsetof(qt_meta_stringdata_TestGui_t, stringdata0) + ofs \
+        - idx * sizeof(QByteArrayData)) \
+    )
+static const qt_meta_stringdata_TestGui_t qt_meta_stringdata_TestGui = {
+    {
+QT_MOC_LITERAL(0, 0, 7), // "TestGui"
+QT_MOC_LITERAL(1, 8, 25), // "testGenericInterfaceSetup"
+QT_MOC_LITERAL(2, 34, 0), // ""
+QT_MOC_LITERAL(3, 35, 24), // "testWindowServiceAddFile"
+QT_MOC_LITERAL(4, 60, 19), // "testFileServiceSave"
+QT_MOC_LITERAL(5, 80, 15), // "testRemoveImage"
+QT_MOC_LITERAL(6, 96, 15) // "testThresholdOp"
+
+    },
+    "TestGui\0testGenericInterfaceSetup\0\0"
+    "testWindowServiceAddFile\0testFileServiceSave\0"
+    "testRemoveImage\0testThresholdOp"
+};
+#undef QT_MOC_LITERAL
+
+static const uint qt_meta_data_TestGui[] = {
+
+ // content:
+       7,       // revision
+       0,       // classname
+       0,    0, // classinfo
+       5,   14, // methods
+       0,    0, // properties
+       0,    0, // enums/sets
+       0,    0, // constructors
+       0,       // flags
+       0,       // signalCount
+
+ // slots: name, argc, parameters, tag, flags
+       1,    0,   39,    2, 0x08 /* Private */,
+       3,    0,   40,    2, 0x08 /* Private */,
+       4,    0,   41,    2, 0x08 /* Private */,
+       5,    0,   42,    2, 0x08 /* Private */,
+       6,    0,   43,    2, 0x08 /* Private */,
+
+ // slots: parameters
+    QMetaType::Void,
+    QMetaType::Void,
+    QMetaType::Void,
+    QMetaType::Void,
+    QMetaType::Void,
+
+       0        // eod
+};
+
+void TestGui::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
+{
+    if (_c == QMetaObject::InvokeMetaMethod) {
+        TestGui *_t = static_cast<TestGui *>(_o);
+        Q_UNUSED(_t)
+        switch (_id) {
+        case 0: _t->testGenericInterfaceSetup(); break;
+        case 1: _t->testWindowServiceAddFile(); break;
+        case 2: _t->testFileServiceSave(); break;
+        case 3: _t->testRemoveImage(); break;
+        case 4: _t->testThresholdOp(); break;
+        default: ;
+        }
+    }
+    Q_UNUSED(_a);
+}
+
+const QMetaObject TestGui::staticMetaObject = {
+    { &QObject::staticMetaObject, qt_meta_stringdata_TestGui.data,
+      qt_meta_data_TestGui,  qt_static_metacall, Q_NULLPTR, Q_NULLPTR}
+};
+
+
+const QMetaObject *TestGui::metaObject() const
+{
+    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
+}
+
+void *TestGui::qt_metacast(const char *_clname)
+{
+    if (!_clname) return Q_NULLPTR;
+    if (!strcmp(_clname, qt_meta_stringdata_TestGui.stringdata0))
+        return static_cast<void*>(const_cast< TestGui*>(this));
+    return QObject::qt_metacast(_clname);
+}
+
+int TestGui::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
+{
+    _id = QObject::qt_metacall(_c, _id, _a);
+    if (_id < 0)
+        return _id;
+    if (_c == QMetaObject::InvokeMetaMethod) {
+        if (_id < 5)
+            qt_static_metacall(this, _c, _id, _a);
+        _id -= 5;
+    } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
+        if (_id < 5)
+            *reinterpret_cast<int*>(_a[0]) = -1;
+        _id -= 5;
+    }
+    return _id;
+}
+QT_END_MOC_NAMESPACE