diff --git a/app/Operations/AbsoluteConvertOp.cpp b/app/Operations/AbsoluteConvertOp.cpp
index 371c593f7082c9bdb3a9440862e9d96f601656ff..27e162b2dad284350e6163267e47a9803b1f9308 100644
--- a/app/Operations/AbsoluteConvertOp.cpp
+++ b/app/Operations/AbsoluteConvertOp.cpp
@@ -52,7 +52,5 @@ void AbsoluteConvertOp::operator()(const imagein::Image_t<double>* from, const s
             }
         }
     }
-
-    outDoubleImage(resImg, "Absolute", false, true, 1.0, false);
-
+    outDoubleImage(resImg, "Absolute", AUTO , AUTO, true, 1.0, false);
 }
diff --git a/app/Operations/DCTOp.cpp b/app/Operations/DCTOp.cpp
index a1720b0aef9ee8d86447a1af0c56b2f9244caeca..4e1470b1646a139bc992bd0c649a180dd0b7f510 100644
--- a/app/Operations/DCTOp.cpp
+++ b/app/Operations/DCTOp.cpp
@@ -61,7 +61,7 @@ void DCTOp::operator()(const imagein::Image* image, const std::map<const imagein
 
     outText(s);
     outText("-------------------------------------------");
-    outDoubleImage(resImg, qApp->translate("DCT", "DCT").toStdString(), true, true, 128., true);
+    outDoubleImage(resImg, qApp->translate("DCT", "DCT").toStdString(), ENABLE,DISABLE, true, 128., true);
     outImage(invImg, qApp->translate("DCT", "inverse DCT").toStdString());
 }
 
diff --git a/app/Operations/DPCMEncodingOp.cpp b/app/Operations/DPCMEncodingOp.cpp
index 3be86109de7946cbba85acb1d50c99f97c3bbe98..6cdfbfd0a628e061b4bfb85105661604df02fcb1 100644
--- a/app/Operations/DPCMEncodingOp.cpp
+++ b/app/Operations/DPCMEncodingOp.cpp
@@ -76,9 +76,9 @@ void DPCMEncodingOp::operator()(const imagein::Image* img, const std::map<const
     string s = micd.execute(image, dialog->getPrediction(), &quant_errorImage, &errorImage,&reconstructedImage, &predictionImage, &coding_error_image, dialog->getQ());
     outText(s);
     outText("-------------------------------------------");
-    outDoubleImage(errorImage, qApp->translate("DPCM", "Prediction error image").toStdString(), true, true, 0.1, false);
-    outDoubleImage(quant_errorImage, qApp->translate("DPCM", "Quantized prediction error image").toStdString(), true, true, 0.1, false);
+    outDoubleImage(errorImage, qApp->translate("DPCM", "Prediction error image").toStdString(), DISABLE, DISABLE, true, 0.1, false);
+    outDoubleImage(quant_errorImage, qApp->translate("DPCM", "Quantized prediction error image").toStdString(), DISABLE, DISABLE, true, 0.1, false);
     outImage(predictionImage, qApp->translate("DPCM", "Prediction image").toStdString());
     outImage(reconstructedImage, qApp->translate("DPCM", "Reconstructed image").toStdString());
-    outDoubleImage(coding_error_image, qApp->translate("DPCM", "Coding error image").toStdString(), true, true, 0.1, false);
+    outDoubleImage(coding_error_image, qApp->translate("DPCM", "Coding error image").toStdString(), ENABLE, ENABLE, true, 0.1, false);
 }
diff --git a/app/Operations/DoubleConvertOp.cpp b/app/Operations/DoubleConvertOp.cpp
index fcd1733229db18a0e85f022ec4b0a29ef3cf9893..fa59b4645dce88806b1783be5fb2d530d7cf739f 100644
--- a/app/Operations/DoubleConvertOp.cpp
+++ b/app/Operations/DoubleConvertOp.cpp
@@ -50,5 +50,5 @@ void DoubleConvertOp::operator()(const imagein::Image* from, const std::map<cons
             }
         }
     }
-    outDoubleImage(resImg, "Double", false, false, false, false);
+    outDoubleImage(resImg, "Double", AUTO, AUTO, false, false, false);
 }
diff --git a/app/Operations/FFTOp.cpp b/app/Operations/FFTOp.cpp
index a4838192d54928ac6812967120c7131097ce4d60..93caaf6c70a11e80726b8beb99508f0798800d65 100644
--- a/app/Operations/FFTOp.cpp
+++ b/app/Operations/FFTOp.cpp
@@ -93,9 +93,10 @@ void FFTOp::operator()(const imagein::Image* image, const map<const imagein::Ima
                 }
             }
         }
+
         /*(imagein::ImageDouble* img, std::string title = "", bool norm=false, bool log=false, double logScale = 1., bool abs = false)*/
-        this->outDoubleImage(phaseImg, qApp->translate("FFTOp", "DFT (Phase)").toStdString(), false, false);
-        this->outDoubleImage(magnitudeImg, qApp->translate("FFTOp", "DFT (Magnitude)").toStdString(), false, true);
+        this->outDoubleImage(phaseImg, qApp->translate("FFTOp", "DFT (Phase)").toStdString(), AUTO, AUTO, false);
+        this->outDoubleImage(magnitudeImg, qApp->translate("FFTOp", "DFT (Magnitude)").toStdString(), AUTO, AUTO, true);
     }
     else {
         auto* realImg = new Image_t<double>(width, height, image->getNbChannels());
@@ -139,12 +140,7 @@ void FFTOp::operator()(const imagein::Image* image, const map<const imagein::Ima
                 }
             }
         }
-//        this->outDoubleImage(realImg, "FFT (real)", true, true);
-//        this->outDoubleImage(imagImg, "FFT (imag)", true, true);
-        /*Offset disabled by default*/
-        this->outDoubleImage(realImg, qApp->translate("FFTOp", "(Real part)").toStdString(), false, true);
-        this->outDoubleImage(imagImg, qApp->translate("FFTOp", "(Imaginary part)").toStdString(), false, true);
+        this->outDoubleImage(realImg, qApp->translate("FFTOp", "(Real part)").toStdString(), AUTO, AUTO, true);
+        this->outDoubleImage(imagImg, qApp->translate("FFTOp", "(Imaginary part)").toStdString(), AUTO, AUTO, true);
     }
-
-
 }
diff --git a/app/Operations/HadamardOp.cpp b/app/Operations/HadamardOp.cpp
index d59c8cba625cc3648b3230af0cec57854c50d1df..927df8988175fb5d66bc27abc024c6c47fff0632 100644
--- a/app/Operations/HadamardOp.cpp
+++ b/app/Operations/HadamardOp.cpp
@@ -109,17 +109,17 @@ void HadamardOp::operator()(const imagein::Image* img, const std::map<const imag
     Image* invImg;
     if(transformBox->currentIndex() == 0) {
         s = Transforms::Hadamard(img, &resImg, &invImg, selection);
-        outDoubleImage(resImg, qApp->translate("Transforms", "Hadamard transform").toStdString(), true, true, 256., true);
+        outDoubleImage(resImg, qApp->translate("Transforms", "Hadamard transform").toStdString(), AUTO, DISABLE, true, 256., true);
         outImage(invImg, qApp->translate("Transforms", "Hadamard reconstruction").toStdString());
     }
     else if(transformBox->currentIndex() == 1) {
         s = Transforms::Haar(img, &resImg, &invImg, selection);
-        outDoubleImage(resImg, qApp->translate("Transforms", "Haar transform").toStdString(), true, true, 256., true);
+        outDoubleImage(resImg, qApp->translate("Transforms", "Haar transform").toStdString(), AUTO, DISABLE, true, 256., true);
         outImage(invImg, qApp->translate("Transforms", "Haar reconstruction").toStdString());
     }
     else if(transformBox->currentIndex() == 2) {
         s = Transforms::cosinus(img, &resImg, &invImg, selection);
-        outDoubleImage(resImg, qApp->translate("Transforms", "cosinus transform").toStdString(), true, true, 256., true);
+        outDoubleImage(resImg, qApp->translate("Transforms", "cosinus transform").toStdString(), AUTO, DISABLE, true, 256., true);
         outImage(invImg, qApp->translate("Transforms", "cosinus reconstruction").toStdString());
     }
     outText(s);
diff --git a/app/Operations/HoughOp.cpp b/app/Operations/HoughOp.cpp
index 6afb5a29e0d9e3e11ea43b58c0833de228638de2..6d25e1772414698eaaeaeff783c7eb747f4118c5 100644
--- a/app/Operations/HoughOp.cpp
+++ b/app/Operations/HoughOp.cpp
@@ -54,7 +54,9 @@ void HoughOp::operator()(const imagein::Image* img, const std::map<const imagein
         resImg = Transforms::hough2(img, dialog->getAngleStep(), dialog->getDistanceStep());
         method1=false;
     }
-    outDoubleImage(resImg, qApp->translate("Hough", "Hough transform").toStdString(), true, true);
+
+    outDoubleImage(resImg, qApp->translate("Hough", "Hough transform").toStdString(), AUTO, AUTO, true);
+
 //    Image* resImg2;
 //    Transforms::hough2_inverse(resImg, &resImg2, 512, 0.);
 //    outImage(resImg2, qApp->translate("Hough", "Hough inverse transform").toStdString());
diff --git a/app/Operations/NoiseOp.cpp b/app/Operations/NoiseOp.cpp
index e1db5510d781570391aa43935589e902475635ee..f52928b6c0e10b7affa1b196df7ba5bdbe161195 100644
--- a/app/Operations/NoiseOp.cpp
+++ b/app/Operations/NoiseOp.cpp
@@ -131,7 +131,8 @@ void NoiseOp::operator()(const ImageWindow* currentWnd, const vector<const Image
                 double value = random.Boolean() ? min : max;
                 image->setPixel(x, y, c, value);
             }
-            this->outDoubleImage(image, qApp->translate("NoiseOp", "impulse noise").toStdString(), wnd->isNormalized(), wnd->isLogScaled());
+
+            this->outDoubleImage(image, qApp->translate("NoiseOp", "impulse noise").toStdString(), AUTO, AUTO, wnd->isLogScaled());
 
         }
     }
@@ -158,11 +159,9 @@ void NoiseOp::operator()(const ImageWindow* currentWnd, const vector<const Image
             for(Image_t<double>::iterator it = image->begin(); it < image->end(); ++it) {
                 *it += normdist.operator()(random, mean, deviation);
             }
-            this->outDoubleImage(image, qApp->translate("NoiseOp", "gaussian noise").toStdString(), wnd->isNormalized(), wnd->isLogScaled());
-
+            this->outDoubleImage(image, qApp->translate("NoiseOp", "gaussian noise").toStdString(), AUTO, AUTO, wnd->isLogScaled());
         }
     }
-
 }
 
 bool NoiseOp::isValidImgWnd(const ImageWindow* imgWnd) const {
diff --git a/app/Operations/PointOp.cpp b/app/Operations/PointOp.cpp
index 20c8b8b95eaaa360365590f9f70e1e17b8e27dc9..c6e543b44c62e523b20d073838ed82a55385b4c1 100644
--- a/app/Operations/PointOp.cpp
+++ b/app/Operations/PointOp.cpp
@@ -508,10 +508,10 @@ void PointOp::operator()(const ImageWindow* currentWnd, const vector<const Image
 
     if(dblResult) {
         if(currentDblWnd) {
-            this->outDoubleImage(resDoubleImg, "", currentDblWnd->isNormalized(), currentDblWnd->isLogScaled());
+            this->outDoubleImage(resDoubleImg, "", AUTO, AUTO, currentDblWnd->isLogScaled());
         }
         else {
-            this->outDoubleImage(resDoubleImg, "", false, false);
+            this->outDoubleImage(resDoubleImg, "", AUTO, AUTO, false);
         }
         delete image;
     }
diff --git a/app/Operations/RandomImgOp.cpp b/app/Operations/RandomImgOp.cpp
index ab36ea7c60b3d5f069a4f20a07d6ba530987accc..b48ffda57d4d09f0e7a9ec82dd2bdb6759a21f71 100644
--- a/app/Operations/RandomImgOp.cpp
+++ b/app/Operations/RandomImgOp.cpp
@@ -160,7 +160,7 @@ void RandomImgOp::operator()(const imagein::Image*, const std::map<const imagein
                 }
             }
         }
-        this->outDoubleImage(resImg, qApp->translate("Operations", "Random image").toStdString(), true);
+        this->outDoubleImage(resImg, qApp->translate("Operations", "Random image").toStdString(), AUTO, AUTO);
 
     }
 }
diff --git a/app/Operations/RejectionRingOp.cpp b/app/Operations/RejectionRingOp.cpp
index 645046870cedeb6094e32d5d0c06b97245818f82..68b5ad2503a2b521738920fe62736109f94f86e0 100644
--- a/app/Operations/RejectionRingOp.cpp
+++ b/app/Operations/RejectionRingOp.cpp
@@ -38,67 +38,69 @@ RejectionRingOp::RejectionRingOp() : Operation(qApp->translate("Operations", "Re
 }
 
 void RejectionRingOp::operator()(const imagein::Image*, const std::map<const imagein::Image*, std::string>&) {
-    QDialog* dialog = new QDialog();
+    QDialog *dialog = new QDialog();
     dialog->setWindowTitle(qApp->translate("Operations", "Rejection ring"));
     dialog->setMinimumWidth(180);
-    QFormLayout* layout = new QFormLayout(dialog);
+    QFormLayout *layout = new QFormLayout(dialog);
 
-    QSpinBox* widthBox = new QSpinBox(dialog);
+    QSpinBox *widthBox = new QSpinBox(dialog);
     widthBox->setRange(0, 65536);
     widthBox->setValue(512);
     layout->insertRow(0, qApp->translate("RejectionRingOp", "Width=Height : "), widthBox);
 
-    QSpinBox* radiusBox = new QSpinBox(dialog);
+    QSpinBox *radiusBox = new QSpinBox(dialog);
     radiusBox->setRange(0, 65536);
     layout->insertRow(1, qApp->translate("RejectionRingOp", "Radius : "), radiusBox);
 
-    QSpinBox* thickBox = new QSpinBox(dialog);
+    QSpinBox *thickBox = new QSpinBox(dialog);
     thickBox->setRange(0, 65536);
     layout->insertRow(2, qApp->translate("RejectionRingOp", "Thickness (beyond radius) : "), thickBox);
 
-    QDialogButtonBox* buttonBox = new QDialogButtonBox(QDialogButtonBox::Ok|QDialogButtonBox::Cancel, Qt::Horizontal, dialog);
+    QDialogButtonBox *buttonBox = new QDialogButtonBox(QDialogButtonBox::Ok | QDialogButtonBox::Cancel, Qt::Horizontal,
+                                                       dialog);
     layout->insertRow(3, buttonBox);
     QObject::connect(buttonBox, SIGNAL(accepted()), dialog, SLOT(accept()));
     QObject::connect(buttonBox, SIGNAL(rejected()), dialog, SLOT(reject()));
 
     QDialog::DialogCode code = static_cast<QDialog::DialogCode>(dialog->exec());
 
-    if(code!=QDialog::Accepted) return;
+    if (code != QDialog::Accepted) return;
 
     //On rcupre la taille de l'image a traiter
-    int nb_ligne,nb_colonne;
+    int nb_ligne, nb_colonne;
     int rayon, epaisseur;
 
-    nb_ligne= widthBox->value(); //1er parametre de l'algorithme
-    rayon=		radiusBox->value(); //2nd parametre de l'algorithme
-    epaisseur=	thickBox->value(); //3me parametre de l'algorithme
+    nb_ligne = widthBox->value(); //1er parametre de l'algorithme
+    rayon = radiusBox->value(); //2nd parametre de l'algorithme
+    epaisseur = thickBox->value(); //3me parametre de l'algorithme
 
-    nb_colonne=nb_ligne;
+    nb_colonne = nb_ligne;
 
-    Image_t<double>* result = new Image_t<double>(nb_ligne, nb_colonne, 1);//image resultat
+    Image_t<double> *result = new Image_t<double>(nb_ligne, nb_colonne, 1);//image resultat
 
-    int i,j;
+    int i, j;
     int icentre, jcentre;
 
-    icentre = (int)(nb_ligne/2.);
-    jcentre = (int)(nb_colonne/2.);
+    icentre = (int) (nb_ligne / 2.);
+    jcentre = (int) (nb_colonne / 2.);
 
-    for(i=0;i<nb_ligne;i++)
-        for(j=0;j<nb_colonne;j++){
+    for (i = 0; i < nb_ligne; i++)
+        for (j = 0; j < nb_colonne; j++) {
             result->setPixelAt(i, j, 1.);
         }
 
-    for(i=0;i<nb_ligne;i++)
-        for(j=0;j<nb_colonne;j++){
-            if( (i-icentre)*(i-icentre) + (j-jcentre)*(j-jcentre) >= rayon*rayon  &&  (i-icentre)*(i-icentre) + (j-jcentre)*(j-jcentre) <= (rayon+epaisseur)*(rayon+epaisseur) )
+    for (i = 0; i < nb_ligne; i++)
+        for (j = 0; j < nb_colonne; j++) {
+            if ((i - icentre) * (i - icentre) + (j - jcentre) * (j - jcentre) >= rayon * rayon &&
+                (i - icentre) * (i - icentre) + (j - jcentre) * (j - jcentre) <=
+                (rayon + epaisseur) * (rayon + epaisseur))
                 result->setPixelAt(i, j, 0.);
         }
 
 
-
     QString name(qApp->translate("RejectionRingOp", "Rejection ring (%1 %2 %3)"));
     name = name.arg(nb_ligne).arg(rayon).arg(epaisseur);
-    outDoubleImage(result, name.toStdString(), true, false);
+    outDoubleImage(result, name.toStdString(),ENABLE,DISABLE);
 }
 
 bool RejectionRingOp::needCurrentImg() const {
diff --git a/app/Operations/SplitHsvOp.cpp b/app/Operations/SplitHsvOp.cpp
index 02a78bbd447aa33146529978f9c1487269d31472..f1a31392ef29bc76f8167a033f08481769fe689f 100644
--- a/app/Operations/SplitHsvOp.cpp
+++ b/app/Operations/SplitHsvOp.cpp
@@ -58,10 +58,9 @@ void SplitHsvOp:: operator()(const imagein::Image* image, const std::map<const i
                 resImgV->setPixelAt(i,j,color.value());
             }
         }
-        this->outDoubleImage(resImgH, qApp->translate("Operations", "Hue").toStdString(),false,false);
-        this->outDoubleImage(resImgS, qApp->translate("Operations", "Saturation").toStdString(),false,false);
-        this->outDoubleImage(resImgV, qApp->translate("Operations", "Value").toStdString(),false,false);
-
+        this->outDoubleImage(resImgH, qApp->translate("Operations", "Hue").toStdString(),DISABLE, DISABLE,false);
+        this->outDoubleImage(resImgS, qApp->translate("Operations", "Saturation").toStdString(),DISABLE, DISABLE,false);
+        this->outDoubleImage(resImgV, qApp->translate("Operations", "Value").toStdString(),DISABLE, DISABLE,false);
 }
 
 
diff --git a/app/Services/FilteringService.cpp b/app/Services/FilteringService.cpp
index 2e71adaca0265840ed3357656d5340b549c2c4ab..5c19e52152a5b92031d2e85cedf894da1ad943a7 100644
--- a/app/Services/FilteringService.cpp
+++ b/app/Services/FilteringService.cpp
@@ -111,7 +111,7 @@ void FilteringService::applyAlgorithm(Filtering* algo)
             if(_dblResult) {
                 DoubleImageWindow* diw = dynamic_cast<DoubleImageWindow*>(_siw);
                 if(diw != NULL) {
-                    riw = new DoubleImageWindow(dblResImg, _siw->getPath(), diw->isNormalized(), diw->isLogScaled());
+                    riw = new DoubleImageWindow(dblResImg, _siw->getPath(), AUTO,AUTO , diw->isLogScaled());
                     /*Enable the output of description text concerning the display imgage processing options that the user can choose*/
                     QObject::connect(riw, SIGNAL(textToShow(QString)), this->_ws, SLOT(outputText(QString)));
                     if(dblResImg->min()<0){
@@ -120,7 +120,7 @@ void FilteringService::applyAlgorithm(Filtering* algo)
                     }
                 }
                 else {
-                    riw = new DoubleImageWindow(dblResImg, _siw->getPath(), true);
+                    riw = new DoubleImageWindow(dblResImg, _siw->getPath(), AUTO,AUTO);
                     /*Enable the output of description text concerning the display imgage processing options that the user can choose*/
                     QObject::connect(riw, SIGNAL(textToShow(QString)), this->_ws, SLOT(outputText(QString)));
                     if(dblResImg->min()<0){
diff --git a/core/Operation.cpp b/core/Operation.cpp
index 471f61bda02b8285f516bd011c6695dac71ad0ce..7c313fde96e2646d0211c4aa2b4327fba7467bc7 100644
--- a/core/Operation.cpp
+++ b/core/Operation.cpp
@@ -19,7 +19,7 @@
 
 #include "Operation.h"
 #include <Widgets/ImageWidgets/StandardImageWindow.h>
-#include <Widgets/ImageWidgets/DoubleImageWindow.h>
+#include "Widgets/ImageWidgets/DoubleImageWindow.h"
 #include <Services/WindowService.h>
 #include "../app/Operations/HoughOp.h"
 
@@ -69,26 +69,48 @@ void GenericOperation::outImage(imagein::Image* img, string title) {
         this->outImgWnd(wnd, title);
 }
 
-void GenericOperation::outDoubleImage(imagein::ImageDouble* img, string title, bool norm, bool log, double logScale, bool abs) {
-        DoubleImageWindow* wnd = new DoubleImageWindow(img, QString(), norm, log, logScale, abs);
-        /*Transmissed through the customized signal, the messages generated by Doubleimage window can be output to the information bar*/
-        QObject::connect(wnd, SIGNAL(textToShow(QString)), this->_ws, SLOT(outputText(QString)));
-        if(HoughOp* v = dynamic_cast<HoughOp*>(this)) {
-                // teste si l'operation effectuee est une transformee de Hough
-                if (v->hough1()) {
-                        wnd->isHough(1, 1);
-                }else{
-                        wnd->isHough(v->getAngleStep(), v->getDistanceStep());
-                }
-                //isHough=true ce qui change les coordonnées des pixels de l'image pour correspondre au domaine de Hough
-        }
-        this->outImgWnd(wnd, title);
-        if(img->min()<0){
-            std::string outputMessage = QObject::tr("Both Offset and Scaling applied : val_display = (127-minValue) > (maxValue-127) ? val_image * 127 / (- minValue) + 127 : val_image * 128 / maxValue + 127\n\n-------------------------------------------").toStdString();
-            outText(outputMessage);
+//void GenericOperation::outDoubleImage(imagein::ImageDouble* img, string title, bool norm, bool log, double logScale, bool abs) {
+//        DoubleImageWindow* wnd = new DoubleImageWindow(img, QString(), norm, log, logScale, abs);
+//        /*Transmissed through the customized signal, the messages generated by Doubleimage window can be output to the information bar*/
+//        QObject::connect(wnd, SIGNAL(textToShow(QString)), this->_ws, SLOT(outputText(QString)));
+//        if(HoughOp* v = dynamic_cast<HoughOp*>(this)) {
+//                // teste si l'operation effectuee est une transformee de Hough
+//                if (v->hough1()) {
+//                        wnd->isHough(1, 1);
+//                }else{
+//                        wnd->isHough(v->getAngleStep(), v->getDistanceStep());
+//                }
+//                //isHough=true ce qui change les coordonnées des pixels de l'image pour correspondre au domaine de Hough
+//        }
+//        this->outImgWnd(wnd, title);
+//        if(img->min()<0){
+//            std::string outputMessage = QObject::tr("Both Offset and Scaling applied : val_display = (127-minValue) > (maxValue-127) ? val_image * 127 / (- minValue) + 127 : val_image * 128 / maxValue + 127\n\n-------------------------------------------").toStdString();
+//            outText(outputMessage);
+//        }
+//}
+
+void GenericOperation::outDoubleImage(imagein::ImageDouble* img, string title, boxSetting scaled, boxSetting offset, bool log, double logScale, bool abs) {
+    auto* wnd = new DoubleImageWindow(img, QString(),scaled, offset, log, logScale, abs);
+
+    /*Transmissed through the customized signal, the messages generated by Doubleimage window can be output to the information bar*/
+    QObject::connect(wnd, SIGNAL(textToShow(QString)), this->_ws, SLOT(outputText(QString)));
+    if(HoughOp* v = dynamic_cast<HoughOp*>(this)) {
+        // teste si l'operation effectuee est une transformee de Hough
+        if (v->hough1()) {
+            wnd->isHough(1, 1);
+        }else{
+            wnd->isHough(v->getAngleStep(), v->getDistanceStep());
         }
+        //isHough=true ce qui change les coordonnées des pixels de l'image pour correspondre au domaine de Hough
+    }
+    this->outImgWnd(wnd, title);
+    if(img->min()<0){
+        std::string outputMessage = QObject::tr("Both Offset and Scaling applied : val_display = (127-minValue) > (maxValue-127) ? val_image * 127 / (- minValue) + 127 : val_image * 128 / maxValue + 127\n\n-------------------------------------------").toStdString();
+        outText(outputMessage);
+    }
 }
 
+
 void GenericOperation::outText(std::string text) {
         if(_ws == NULL) return;
         _ws->addText(text);
diff --git a/core/Operation.h b/core/Operation.h
index 5ce7988091586abba0859add5451a530ef8935e5..546f4ba6a066d8c451ad1238c570ba535cbb32ec 100644
--- a/core/Operation.h
+++ b/core/Operation.h
@@ -102,8 +102,6 @@ virtual bool needCurrentImg() const = 0;
 virtual bool isValidImgWnd(const genericinterface::ImageWindow* imgWnd) const = 0;
 
 protected:
-
-
 /**
  * @brief %Output a standard Image to the user interface.
 
@@ -127,9 +125,9 @@ void outImage(imagein::Image* img, std::string title = "");
  * @param logScale The logarithm scale constant to apply if the Image is displayed using log. scale (value from 8^-3 to 8^3, see genericinterface::DoubleImageWindow for more details).
  * @param abs wether to display an absolute value version of the Image (doesn't affect the data contained in the image, compatible with any other options).
  */
-void outDoubleImage(imagein::ImageDouble* img, std::string title = "", bool norm=false, bool log=false, double logScale = 1., bool abs = false);
-
+//void outDoubleImage(imagein::ImageDouble* img, std::string title = "", bool norm=false, bool log=false, double logScale = 1., bool abs = false);
 
+void outDoubleImage(imagein::ImageDouble* img, std::string title = "", boxSetting scaled = AUTO, boxSetting offset = AUTO, bool log = false, double logScale = 1., bool abs = false);
 /**
  * @brief %Output some text to the user interface.
  *
diff --git a/lib/detiq-t b/lib/detiq-t
index 5b3c718a78ac9fe278418cd4d6fbc06dc6526693..0d1041b4e2f7e15b568055b0d8ffbd7bf9e7173b 160000
--- a/lib/detiq-t
+++ b/lib/detiq-t
@@ -1 +1 @@
-Subproject commit 5b3c718a78ac9fe278418cd4d6fbc06dc6526693
+Subproject commit 0d1041b4e2f7e15b568055b0d8ffbd7bf9e7173b