[MICD] Improvements on algo

Rename some variables
Remove unnecessary variables
Add missing letters in comments / strings
Add comments

app/Operations/MICD.cpp

@@ -51,55 +51,53 @@ string MICD::execute( const GrayscaleImage *im, Prediction prediction_alg, image
         throw "Error in MICD::execute:\nquantdef = NULL";
     }
     string returnval;
-    int nbl,nbc,size,rep,i,j,pred,ier,ireco,icode;
+    int imgHeight,imgWidth,pred,ier,ireco,icode;
+
     float pi[512],nbpt = 0;
     double h = 0.;
-    rep = prediction_alg;
 
-    nbl = im->getHeight();
-    nbc = im->getWidth();
-    size = nbc * nbl;
+    imgHeight = im->getHeight();
+    imgWidth = im->getWidth();
 
-    int po;
-    int temp_p;
     /* initialisation de la loi de quantification */
     set_levels();
     codlq(0);
+
     /* allocation mmoire pour l'image d'erreur de prdiction */
-    ImageDouble *error_prediction_image = new ImageDouble(nbc, nbl, 1);
+    ImageDouble *error_prediction_image = new ImageDouble(imgWidth, imgHeight, 1);
     Image *reconstructed_image = new GrayscaleImage(*im);
-    // File these images with all values of zero
-    long wcounter, hcounter;
-    for( hcounter=0; hcounter< nbl; hcounter++ ) {
-        for( wcounter=0; wcounter< nbc; wcounter++ ) {
-            error_prediction_image->setPixelAt(wcounter, hcounter, 0);
+
+    // Init the error image with 0 values
+    for(int i=0; i < imgHeight; i++) {
+        for(int j=0; j< imgWidth; j++) {
+            error_prediction_image->setPixelAt(j, i, 0);
         }
     }
 
-    /* mise  0 du tableau des probas servant pour le calcul de
+    /* mise a 0 du tableau des probas servant pour le calcul de
     l'entropie de l'erreur de prdiction */
-    for(i=0 ; i<512 ; i++) pi[i]= 0.;
+    for(int i=0 ; i<512 ; i++) pi[i]= 0.;
 
     /* codage de l'image */
-    for(i=1; i<nbl ; i++)
+    for(int i=1; i<imgHeight ; i++)
     {
-        for(j=1; j<nbc ; j++)
+        for(int j=1; j<imgWidth ; j++)
         {
-            if(rep == PX_EQ_A) {
-                temp_p = reconstructed_image->getPixelAt( j - 1, i );
-                pred = temp_p;
-            }
-            else if(rep == PX_EQ_B) {
-                temp_p = reconstructed_image->getPixelAt( j, i - 1);
-                pred = temp_p;
-            }
-            else if(rep == PX_EQ_APC) {
-                temp_p = reconstructed_image->getPixelAt( j - 1, i );
-                pred = (int)temp_p;
-                temp_p = reconstructed_image->getPixelAt( j, i - 1 );
-                pred = ( pred + (int)temp_p ) / 2;
-            }
-            else if(rep == PX_EQ_Q) {
+            switch (prediction_alg) {
+            int AplusC;
+            float A,B,C;
+
+            case PX_EQ_A:
+                pred = reconstructed_image->getPixelAt(j-1, i);
+                break;
+            case PX_EQ_B:
+                pred = reconstructed_image->getPixelAt(j, i-1);
+                break;
+            case PX_EQ_APC:
+                AplusC = reconstructed_image->getPixelAt(j-1, i) + reconstructed_image->getPixelAt(j, i-1);
+                pred = AplusC / 2;
+                break;
+            case PX_EQ_Q:
                 /*
                 Modified Graham's Algorithm:
                 if |B-C| - Q <= |B-A| <= |B-C| + Q
@@ -110,43 +108,43 @@ string MICD::execute( const GrayscaleImage *im, Prediction prediction_alg, image
                     else
                             P(X) = C
                 */
-                float A = im->getPixelAt( j - 1, i );
-                float B = im->getPixelAt( j - 1, i - 1 );
-                float C = im->getPixelAt( j, i - 1 );
+                A = im->getPixelAt(j-1, i);
+                B = im->getPixelAt(j-1, i-1);
+                C = im->getPixelAt(j,   i-1);
+
                 if( ((fabs(B-C) - Q) <= fabs(B-A)) &&
                         (fabs(B-A) <= (fabs(B-C) + Q)) ) {
                     pred = (uint8_t)((A + C) / 2);
-                }
-                else {
+                } else {
                     if( fabs(B-A) > fabs(B-C) ) {
                         pred = (uint8_t)A;
-                    }
-                    else {
+                    } else {
                         pred = (uint8_t)C;
                     }
                 }
+                break;
+            default:
+                break;
             }
 
-            temp_p = reconstructed_image->getPixelAt( j, i );
-            ier = (int)temp_p - pred;
+            depth_default_t thePixel = reconstructed_image->getPixelAt(j, i);
+            ier = (int) thePixel - pred;
+
             codec(0,ier,&icode,&ireco);
-            pi[ier+255]++;      /* proba associe  l'erreur de prdiction */
+
+            pi[ier+255]++;      /* proba associe a l'erreur de prdiction */
             nbpt++;
 
-            int tempvalue;
-            tempvalue = ier + 128;
-            po = tempvalue;
-            error_prediction_image->setPixelAt( j, i, po );
-            tempvalue = pred + ireco;
-            if( tempvalue > 255 ) tempvalue = 255;
-            if( tempvalue < 0 ) tempvalue = 0;
-            po = tempvalue;
-            reconstructed_image->setPixelAt( j, i, po );
+            error_prediction_image->setPixelAt(j, i, ier + 128);
+
+            int tempvalue = pred + ireco;
+            // Crop the value in [0,255]
+            reconstructed_image->setPixelAt(j, i, tempvalue > 255 ? 255 : tempvalue < 0 ? 0 : tempvalue);
         }
     }
 
-    /* calcul de l'entropie de l'image d'erreur de prdiction */
-    for(i=0 ; i<512 ; i++)
+    /* calcul de l'entropie de l'image d'erreur de prediction */
+    for(int i=0 ; i < 512 ; i++)
     {
         if(pi[i] != 0) {
             pi[i] /= nbpt;
@@ -228,7 +226,7 @@ void MICD::set_levels() {
 
 string MICD::print_iloiqu() {
     string returnval;
-    returnval = "seuils de dcision --------------- niveaux de reconstruction\n";
+    returnval = "seuils de decision --------------- niveaux de reconstruction\n";
     int counter;
     char buffer[100];
     for( counter=1; counter<= iloiqu[0]*2-1; counter++ ) {