Improved quantification dialog

app/Operations/QuantificationDialog.cpp

@@ -33,10 +33,15 @@
 #include <QFileDialog>
 
 using namespace imagein;
-QuantificationDialog::QuantificationDialog(QWidget *parent) :
-    QDialog(parent)
+QuantificationDialog::QuantificationDialog(QWidget *parent, QString imgName) :
+    QDialog(parent), _editorOnly(imgName.isEmpty())
 {
-    setWindowTitle(QString(tr("Quantification")));
+    if(_editorOnly) {
+       this->setWindowTitle(tr("Quantification file editor"));
+    }
+    else {
+       this->setWindowTitle(tr("Quantification of %1").arg(imgName));
+    }
     setMinimumWidth(180);
     QFormLayout* layout = new QFormLayout(this);
     setLayout(layout);
@@ -47,8 +52,10 @@ QuantificationDialog::QuantificationDialog(QWidget *parent) :
 
     _quantBox = new QComboBox();
     _quantBox->addItem(tr("Linear with centered value"));
-    _quantBox->addItem(tr("Non linear with centered value"));
-    _quantBox->addItem(tr("Non linear with mean value"));
+    if(!_editorOnly) {
+        _quantBox->addItem(tr("Non linear with centered value"));
+        _quantBox->addItem(tr("Non linear with mean value"));
+    }
     _quantBox->addItem(tr("Custom"));
     layout->insertRow(0, tr("Quantification : "), _quantBox);
     layout->insertRow(1, tr("Number of values : "), _sizeBox);
@@ -75,17 +82,25 @@ QuantificationDialog::QuantificationDialog(QWidget *parent) :
     QObject::connect(_sizeBox, SIGNAL(valueChanged(int)), _quantWidget, SLOT(setNbThreshold(int)));
     QObject::connect(_quantBox, SIGNAL(currentIndexChanged(int)), this, SLOT(methodChanged(int)));
 
+    if(_editorOnly) {
+        buttonBox->button(QDialogButtonBox::Cancel)->setVisible(false);
+        buttonBox->button(QDialogButtonBox::Ok)->setText(tr("Exit"));
+    }
+    else {
+        buttonBox->button(QDialogButtonBox::Ok)->setText(tr("Apply"));
+    }
 }
 
 
 void QuantificationDialog::methodChanged(int method) {
-    _editorWidget->setVisible(method == 3);
-    _saveButton->setEnabled(method==3 || method == 0);
+    _editorWidget->setVisible((_editorOnly && method == 1) || (!_editorOnly && method == 3));
+    _saveButton->setEnabled(_editorOnly || method==3 || method == 0);
     this->adjustSize();
 }
 Quantification QuantificationDialog::getQuantif(const Image* image, unsigned int c) {
 
     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;
@@ -94,6 +109,15 @@ Quantification QuantificationDialog::getQuantif(const Image* image, unsigned int
     }
 }
 
+Quantification QuantificationDialog::getQuantif() {
+    int size = _sizeBox->value();
+    if(!_editorOnly) return Quantification::linearQuant(size);
+    switch(_quantBox->currentIndex()) {
+        case 2: return _quantWidget->getQuantif(); break;
+        default: return Quantification::linearQuant(size); break;
+    }
+}
+
 void QuantificationDialog::open() {
 
     QString filename = QFileDialog::getOpenFileName(this, tr("Open a file"), "", tr("Loi de quantification (*.loi)"));
@@ -101,16 +125,17 @@ void QuantificationDialog::open() {
     Quantification q(filename.toStdString());
     _quantWidget->setQuantif(q);
     _sizeBox->setValue(q.size);
-    _quantBox->setCurrentIndex(3);
+    _quantBox->setCurrentIndex(_editorOnly ? 1 : 3);
 }
 
 void QuantificationDialog::save() {
     QString filename = QFileDialog::getSaveFileName(this, tr("Save to file"), "", tr("Loi de quantification (*.loi)"));
     if(filename.isEmpty()) return;
-    switch(_quantBox->currentIndex()) {
-        case 0: Quantification::linearQuant(this->_sizeBox->value()).saveAs(filename.toStdString()); break;
-        case 3: _quantWidget->getQuantif().saveAs(filename.toStdString()); break;
-        default: return;
+    if(_quantBox->currentIndex() == 0) {
+        Quantification::linearQuant(this->_sizeBox->value()).saveAs(filename.toStdString());
+    }
+    else if((_editorOnly && _quantBox->currentIndex()) == 1 || (!_editorWidget && _quantBox->currentIndex() == 3)) {
+        _quantWidget->getQuantif().saveAs(filename.toStdString());
     }
 }
 

app/Operations/QuantificationDialog.h

@@ -31,8 +31,9 @@ class QuantificationDialog : public QDialog
     Q_OBJECT
 public:
     enum QuantMethod {LinearQuant, NonLinearQuant, NonLinearQuantOptimized};
-    explicit QuantificationDialog(QWidget *parent = 0);
+    explicit QuantificationDialog(QWidget *parent = 0, QString imgName = QString());
     Quantification getQuantif(const imagein::Image *image, unsigned int c);
+    Quantification getQuantif();
 signals:
     
 public slots:
@@ -45,6 +46,7 @@ protected:
         QuantificationWidget* _quantWidget;
         QWidget* _editorWidget;
         QPushButton* _saveButton;
+        bool _editorOnly;
 };
 
 #endif // QUANTIFICATIONDIALOG_H

app/Operations/QuantificationOp.cpp

@@ -34,37 +34,46 @@ QuantificationOp::QuantificationOp() : Operation(qApp->translate("Operations", "
 
 
 bool QuantificationOp::needCurrentImg() const {
-    return true;
+    return false;
 }
 
-void QuantificationOp::operator()(const imagein::Image* image, const std::map<const imagein::Image*, std::string>&) {
+void QuantificationOp::operator()(const imagein::Image* image, const std::map<const imagein::Image*, std::string>& imgList) {
+    QuantificationDialog* dialog;
+    if(image != NULL) {
+        QString imgName = QString::fromStdString(imgList.find(image)->second);
+        dialog = new QuantificationDialog(QApplication::activeWindow(), imgName);
+    }
+    else {
+        dialog = new QuantificationDialog(QApplication::activeWindow());
+    }
 
-    QuantificationDialog* dialog = new QuantificationDialog(QApplication::activeWindow());
     QDialog::DialogCode code = static_cast<QDialog::DialogCode>(dialog->exec());
 
 
     if(code!=QDialog::Accepted) return;
 
-    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.size; ++i) {
-            cout << (int)quantification.values[i] << ".";
-        }
-        cout << endl;
-        for(int i = 0; i < quantification.size-1; ++i) {
-            cout << quantification.threshold[i] << ".";
-        }
-        cout << endl;
-        Quantifier quantifier = Quantifier(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, quantifier.valueOf(value));
+    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.size; ++i) {
+                cout << (int)quantification.values[i] << ".";
+            }
+            cout << endl;
+            for(int i = 0; i < quantification.size-1; ++i) {
+                cout << quantification.threshold[i] << ".";
+            }
+            cout << endl;
+            Quantifier quantifier = Quantifier(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, quantifier.valueOf(value));
+                }
             }
         }
+        outImage(resImg, qApp->translate("QuantificationOp", "quantified").toStdString());
     }
 
-    outImage(resImg, qApp->translate("QuantificationOp", "quantified").toStdString());
 }