src/snark/quad_resedu.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/quad_resedu.cpp $
   5  $LastChangedRevision: 89 $
   6  $Date: 2014-07-02 17:24:53 -0400 (Wed, 02 Jul 2014) $
   7  $Author: agulati $
   8  ***********************************************************
   9
  10  X IS THE RECONSTRUCTED PICTURE
  11
  12  (A)  R = SA*C**T*M#*A*(M*X-P)+(SB*C**T*B**L+SC*C**(T-1))*(X-XBAR)
  13
  14  W IS TEMPORARY STORAGE VECTOR
  15
  16  IF T IS ODD OR DELTA CONSTANT WITH AOPT=1 THEN:
  17  G = C**T*R    (G=R)
  18
  19
  20  OR
  21  (B)  R = M#*A*(M*X-P) AND FOR CONSTANT DELTA AND AOPT=1
  22  G = D**2*R    (G=R)
  23
  24  (A)                          (B)
  25
  26  1.       R=SA*M#*A*(M*X-P)            SAME
  27  2.                                    R=D**2*R
  28  3.       W=X-XBAR
  29  4.       X=B**L*W
  30  5.       R=R+SB*W
  31  6.       R=C**T*R
  32  7.       W=X-XBAR
  33  8.       W=C**(T-1)*W
  34  9.       R=R+SC*W
  35  */
  36
  37 #include <cstdio>
  38
  39 #include "blkdta.h"
  40 #include "geom.h"
  41 #include "consts.h"
  42 #include "blob.h"
  43
  44 #include "quad.h"
  45
  46 void quad_class::resedu(REAL* x, REAL* r, REAL* w, REAL* d, INTEGER* list,
  47                 REAL* weight, REAL* f, REAL* s)
  48 {
  49         INTEGER i;
  50         INTEGER area;
  51
  52         if (Blob.pix_basis)
  53         {
  54                 area = GeoPar.area;
  55         }
  56         else
  57         {
  58                 area = Blob.area;
  59         }
  60
  61         if (sa > Consts.zero)
  62         {
  63
  64 //C1.
  65                 mtamxp(x, r, list, weight);
  66
  67                 if (copt <= 3)
  68                 {
  69
  70                         // IF DELTA IS NOT CONSTAT OR AOPT NOT 1 RETURN
  71
  72                         if ((bopt > 2) || (aopt != 1))
  73                         {
  74                                 return;
  75                         }
  76 //C2.
  77
  78                         for (i = 0; i < area; i++)
  79                         {
  80                                 r[i] *= d[i];
  81                         }
  82                         return;
  83                 }
  84         }
  85
  86         if (sb > Consts.zero)
  87         {
  88
  89 //C3.
  90
  91                 if (fopt > 2)
  92                 {
  93
  94                         for (i = 0; i < area; i++)
  95                         {
  96                                 w[i] = x[i] - f[i];
  97                         }
  98                 }
  99                 else
 100                 {
 101                         for (i = 0; i < area; i++)
 102                         {
 103                                 w[i] = x[i] - xbar;
 104                         }
 105                 }
 106
 107                 if (l != 0)
 108                 {
 109
 110 //C4.
 111
 112                         if (Blob.pix_basis)
 113                         {
 114                                 adsmos(w, l, bw1, bw2, bw3, bbcon);
 115                         }
 116                         else
 117                         {
 118                                 badsmos(w, l, bw1, bw2, bbcon);
 119                         }
 120 //C5.
 121                 }
 122                 for (i = 0; i < area; i++)
 123                 {
 124                         r[i] += sb * w[i];
 125                 }
 126         }
 127 //C6.
 128
 129         if (copt != 5)
 130         {
 131                 if (Blob.pix_basis)
 132                 {
 133                         adsmos(r, t, cw1, cw2, cw3, cbcon);
 134                 }
 135                 else
 136                 {
 137                         badsmos(r, t, cw1, cw2, cbcon);
 138                 }
 139         }
 140
 141         if (sc > Consts.zero)
 142         {
 143
 144 //C7.
 145
 146                 if (fopt > 2)
 147                 {
 148
 149                         for (i = 0; i < area; i++)
 150                         {
 151                                 w[i] = x[i] - f[i];
 152                         }
 153                 }
 154                 else
 155                 {
 156
 157                         for (i = 0; i < area; i++)
 158                         {
 159                                 w[i] = x[i] - xbar;
 160                         }
 161                 }
 162
 163 //C8.
 164
 165                 if ((t - 1 > 0) && (copt != 5))
 166                 {
 167                         if (Blob.pix_basis)
 168                         {
 169                                 adsmos(w, t - 1, cw1, cw2, cw3, cbcon);
 170                         }
 171                         else
 172                         {
 173                                 badsmos(w, t - 1, cw1, cw2, cbcon);
 174                         }
 175                 }
 176
 177 //C9.
 178
 179                 for (i = 0; i < area; i++)
 180                 {
 181                         r[i] += sc * w[i];
 182                 }
 183         }
 184
 185 // FOR ONE STEP METHOD WITH DIRECT COMPUTATION OF RESIDUE
 186 // WHICH DO NOT USE DELTAC OR DELTAD COMPUTE THE CORRECTING VECTOR
 187 // MODIFY BY THE SPLITTING
 188
 189         if ((aopt != 1) || (bopt >= 3) || (gopt == 0))
 190         {
 191                 return;
 192         }
 193         for (i = 0; i < area; i++)
 194         {
 195                 r[i] *= s[i];
 196         }
 197
 198         if (copt != 5)
 199         {
 200                 if (Blob.pix_basis)
 201                 {
 202                         adsmos(r, t, cw1, cw2, cw3, cbcon);
 203                 }
 204                 else
 205                 {
 206                         badsmos(r, t, cw1, cw2, cbcon);
 207                 }
 208         }
 209         return;
 210 }