src/snark/smooth.cpp

   1 /*
   2  ***********************************************************
   3  $SNARK_Header: S N A R K  1 4 - A PICTURE RECONSTRUCTION PROGRAM $
   4  $HeadURL: svn://dig.cs.gc.cuny.edu/snark/trunk/src/snark/smooth.cpp $
   5  $LastChangedRevision: 97 $
   6  $Date: 2014-07-02 20:07:41 -0400 (Wed, 02 Jul 2014) $
   7  $Author: agulati $
   8  ***********************************************************
   9
  10  A NINE-POINT WEIGHTED, NON-LINEAR SMOOTHING PROCEDURE.
  11  FOR DETAILS, SEE THE SNARK MANUAL.
  12  */
  13
  14 #include <cstdio>
  15 #include <cmath>
  16
  17 #include "blkdta.h"
  18 #include "consts.h"
  19 #include "uiod.h"
  20
  21 #include "smooth.h"
  22
  23 void smooth(
  24 REAL* a, // image
  25                 INTEGER m, // number of rows
  26                 INTEGER n, // number of columns
  27                 REAL thresh, // treshold
  28                 REAL w1, // weight of center
  29                 REAL w2, // weight of horizontal and vertical neighbous
  30                 REAL w3 // weight of diagonal neighbous
  31                 )
  32 {
  33         REAL* row1 = new REAL[n]; // row buffer 1
  34         REAL* row2 = new REAL[n]; // row buffer 2
  35         REAL* pres = row2; // current row before smooth
  36         REAL* prev = row1; // previous row before smooth
  37
  38         BOOLEAN once = TRUE; // message flag
  39
  40         INTEGER l = 0; // curent pixel index
  41         REAL centre; // curent pixel value
  42
  43         REAL smuth; // weighted sum of neighbours
  44         REAL divide; // sum of weights
  45         REAL value; // neighbour value
  46
  47         for (int i = 0; i < m; i++)
  48         { // for every row
  49
  50                 REAL* itemp = prev; // swap the buffers
  51                 prev = pres;
  52                 pres = itemp;
  53
  54                 for (int j = 0; j < n; j++)
  55                 { // for every column
  56
  57                         centre = a[l];
  58                         pres[j] = centre;
  59                         smuth = w1 * centre;
  60                         divide = w1;
  61
  62                         if (i != 0)
  63                         { // if not first row
  64                                 if (j != 0)
  65                                 { // if not first column
  66                                         value = prev[j - 1]; // prev row prev column
  67
  68                                         if ((REAL) fabs(value - centre) <= thresh)
  69                                         {
  70                                                 smuth += w3 * value;
  71                                                 divide += w3;
  72                                         }
  73                                 }
  74
  75                                 value = prev[j]; // prev row same column
  76
  77                                 if ((REAL) fabs(value - centre) <= thresh)
  78                                 {
  79                                         smuth += w2 * value;
  80                                         divide += w2;
  81                                 }
  82
  83                                 if (j != (n - 1))
  84                                 { // if not last column
  85                                         value = prev[j + 1]; // prev row next column
  86
  87                                         if ((REAL) fabs(value - centre) <= thresh)
  88                                         {
  89                                                 smuth += w3 * value;
  90                                                 divide += w3;
  91                                         }
  92                                 }
  93                         }
  94
  95                         if (j != 0)
  96                         { // if not first column
  97                                 value = pres[j - 1]; // same row prev column
  98
  99                                 if ((REAL) fabs(value - centre) <= thresh)
 100                                 {
 101                                         smuth += w2 * value;
 102                                         divide += w2;
 103                                 }
 104                         }
 105
 106                         if (j != (n - 1))
 107                         { // if not last column
 108                                 value = a[l + 1]; // same row next column
 109
 110                                 if ((REAL) fabs(value - centre) <= thresh)
 111                                 {
 112                                         smuth += w2 * value;
 113                                         divide += w2;
 114                                 }
 115                         }
 116
 117                         if (i != (m - 1))
 118                         { // if not last row
 119                                 if (j != 0)
 120                                 { // if not first column
 121                                         value = a[l + n - 1]; // next row prev column
 122
 123                                         if ((REAL) fabs(value - centre) <= thresh)
 124                                         {
 125                                                 smuth += w3 * value;
 126                                                 divide += w3;
 127                                         }
 128                                 }
 129
 130                                 value = a[l + n]; // next row same column
 131
 132                                 if ((REAL) fabs(value - centre) <= thresh)
 133                                 {
 134                                         smuth += w2 * value;
 135                                         divide += w2;
 136                                 }
 137
 138                                 if (j != (n - 1))
 139                                 { // if not last column
 140                                         value = a[l + n + 1]; // next row next column
 141
 142                                         if ((REAL) fabs(value - centre) <= thresh)
 143                                         {
 144                                                 smuth += w3 * value;
 145                                                 divide += w3;
 146                                         }
 147                                 }
 148                         }
 149
 150                         if ((REAL) fabs(divide) > Consts.zero)
 151                         {
 152                                 a[l] = smuth / divide;
 153                         }
 154                         else
 155                         {
 156                                 if (once)
 157                                 {
 158                                         fprintf(output, "\n **** warning - sum of weights = zero");
 159                                         once = FALSE;
 160                                 }
 161
 162 //pragma message( "to check!" )
 163                                 a[l] = ((smuth - Consts.infin) > 0) ? (REAL) 1.0 : (smuth == Consts.infin) ? (REAL) 0.0 : (REAL) -1.0;
 164                         }
 165
 166                         l++;
 167                 }
 168         }
 169
 170         delete[] row1; // bug 92 - Lajos - 03/02/2005
 171         delete[] row2; // bug 92 - Lajos - 03/02/2005
 172
 173         return;
 174 }