added pretty print in log for quantization

app/Operations/Quantification.cpp

@@ -208,7 +208,7 @@ Quantification Quantification::lloydMaxQuant(int size, const Image* image, unsig
     Histogram histogram = image->getHistogram(c);
     int som_lum = 0;
     int nb_points = 0;
-    int cpt = 6;
+    int cpt = 12;
 
     // initialisation : repartion lineaire des niveaux de quantification
     Quantification quant = linearQuant(size);
@@ -230,7 +230,10 @@ Quantification Quantification::lloydMaxQuant(int size, const Image* image, unsig
                 nb_points += histogram[i];
             }
 
-            quant._values[j]= (int) quant._values[j]*(som_lum/nb_points) / (som_lum/nb_points);
+            quant._values[j]= (int) (som_lum/nb_points);
+
+            //weird equation : 
+            // quant._values[j]= (int) quant._values[j]*(som_lum/nb_points) / (som_lum/nb_points);
         }//for (parcours du tableau de valeurs)
 
         cpt--;

app/Operations/QuantificationDialog.cpp

@@ -98,16 +98,31 @@ void QuantificationDialog::methodChanged(int method) {
     this->adjustSize();
 }
 
-Quantification QuantificationDialog::getQuantif(const Image* image, unsigned int c) {
+Quantification QuantificationDialog::getQuantif(const Image* image, unsigned int c, std::string &to_print) {
     int size = _sizeBox->value();
     if(_editorOnly) return Quantification::linearQuant(size);
     switch(_quantBox->currentIndex()) {
-        case 1: return Quantification::nonLinearQuant(size, image, c); break;
-        case 2: return Quantification::nonLinearQuantOptimized(size, image, c); break;
-        case 3: return _quantWidget->getQuantif(); break;
-        case 4: return Quantification::lloydMaxQuant(size, image, c); break;
-
-        default: return Quantification::linearQuant(size); break;
+        case 1: 
+                to_print = "Quantification non lineaire a valeur centrees :";
+                return Quantification::nonLinearQuant(size, image, c); 
+                break;
+        case 2: 
+                to_print = "Quantification non lineaire a moyennes : ";
+                return Quantification::nonLinearQuantOptimized(size, image, c); 
+                break;
+        case 3: 
+                to_print = "Quantification personnalisée :";
+                return _quantWidget->getQuantif(); 
+                break;
+        case 4: 
+                to_print = "Quantification LloydMax :";
+                return Quantification::lloydMaxQuant(size, image, c);
+                break;
+
+        default: 
+                to_print = "Quantification lineaire a valeurs centrees :";
+                return Quantification::linearQuant(size); 
+                break;
     }
 }
 

app/Operations/QuantificationDialog.h

@@ -33,7 +33,7 @@ class QuantificationDialog : public QDialog
 public:
     enum QuantMethod {LinearQuant, NonLinearQuant, NonLinearQuantOptimized};
     explicit QuantificationDialog(QWidget *parent = 0, QString imgName = QString());
-    Quantification getQuantif(const imagein::Image *image, unsigned int c);
+    Quantification getQuantif(const imagein::Image *image, unsigned int c, std::string &);
     Quantification getQuantif();
 signals:
     

app/Operations/QuantificationOp.cpp

@@ -37,10 +37,58 @@ bool QuantificationOp::needCurrentImg() const {
     return false;
 }
 
+string QuantificationOp::quantificationOpLog(unsigned int c, Quantification * quant){
+    char buffer[30];
+    string output_msg;
+    int val;    
+    sprintf(buffer, "\nCanal %d : \n", c);
+    output_msg += buffer;
+
+    output_msg += "             Valeurs :  ";
+
+    for(int i = 0; i < quant->nbValues(); ++i) {
+        
+        val =(int)quant->value(i);
+        if(i != 0) output_msg += " |  ";
+                
+        sprintf(buffer, "%d ", val);
+        output_msg += buffer;
+        if(val < 10) output_msg += " ";
+        if(val < 100 ) output_msg += " ";
+
+
+    }
+    output_msg += "\n";
+    output_msg += "             Seuils    :       ";
+            
+    for(int i = 0; i < quant->nbThresholds(); ++i) {
+        val =(int)quant->threshold(i);
+
+        if(i != 0) output_msg += " |  ";
+                
+        sprintf(buffer, "%d ", val);
+        output_msg += buffer;
+                
+        if(val < 10) output_msg += " ";
+        if(i+1<quant->nbThresholds()) {
+             if((val < 100 )&& ((int)quant->threshold(i+1) < 100))   output_msg += " ";
+        }
+    }
+
+    output_msg += "\n";
+
+    return output_msg;
+}
+
+
 void QuantificationOp::operator()(const imagein::Image* image, const std::map<const imagein::Image*, std::string>& imgList) {
+    string quantType;
+    string output_msg ="" ;
+
     QuantificationDialog* dialog;
     if(image != NULL) {
         QString imgName = QString::fromStdString(imgList.find(image)->second);
+        
         dialog = new QuantificationDialog(QApplication::activeWindow(), imgName);
     }
     else {
@@ -53,24 +101,28 @@ void QuantificationOp::operator()(const imagein::Image* image, const std::map<co
     if(code!=QDialog::Accepted) return;
 
     if(image != NULL) {
+        
         Image* resImg = new Image(image->getWidth(), image->getHeight(), image->getNbChannels());
         for(unsigned int c = 0; c < image->getNbChannels(); ++c) {
-            Quantification quantification = dialog->getQuantif(image, c);
-            for(int i = 0; i < quantification.nbValues(); ++i) {
-                cout << (int)quantification.value(i) << ".";
-            }
-            cout << endl;
-            for(int i = 0; i < quantification.nbThresholds(); ++i) {
-                cout << quantification.threshold(i) << ".";
-            }
-            cout << endl;
+            
+            
+            Quantification quantification = dialog->getQuantif(image, c, quantType);
+            
+            //Generate the text to print in the information window
+            output_msg += quantificationOpLog(c, &quantification);
+
+
             for(unsigned int j = 0; j < image->getHeight(); ++j) {
                 for(unsigned int i = 0; i < image->getWidth(); ++i) {
+                    
                     const Image::depth_t value = image->getPixelAt(i, j, c);
                     resImg->setPixelAt(i, j, c, quantification.valueOf(value));
                 }
             }
         }
+        
+        outText(quantType);
+        outText(output_msg);
         outImage(resImg, qApp->translate("QuantificationOp", "quantified").toStdString());
     }
 

app/Operations/QuantificationOp.h

@@ -29,6 +29,8 @@ public:
 
     QuantificationOp();
 
+    std::string quantificationOpLog(unsigned int channel, Quantification * quant);
+
     void operator()(const imagein::Image*, const std::map<const imagein::Image*, std::string>&);
 
     bool needCurrentImg() const;