src/snark/pick.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/pick.cpp $
   5  $LastChangedRevision: 80 $
   6  $Date: 2014-07-01 21:01:54 -0400 (Tue, 01 Jul 2014) $
   7  $Author: agulati $
   8  ***********************************************************
   9
  10  EACH CALL TO PICK RETURNS THE NUMBER NR OF A NEW RAY AND THE
  11  NUMBER NP OF A NEW PROJECTION ACCORDING TO THE SELECTION OF
  12  SEQUENCING MADE BY THE SELECT COMMAND.  DEFAULT IS SEQUENTIAL RAY
  13  SELECTION WITH RAY-STEP = PROJECTION-STEP = 1
  14  */
  15
  16 #include <cstdio>
  17
  18 #include "blkdta.h"
  19 #include "geom.h"
  20 #include "raysel.h"
  21 #include "uiod.h"
  22 #include "geom.h"
  23 #include "effpick.h"
  24
  25 #include "DIGRand.h"
  26
  27 #include "pick.h"
  28
  29 void pick(INTEGER* np, INTEGER* nr)
  30 {
  31
  32         switch (RaySel.stype)
  33         {
  34
  35         //EFFICIENT RAY PICKING
  36
  37         case 7: // efficient picking
  38
  39                 if (RaySel.effcnt % (RaySel.numray * GeoPar.prjnum) == 0)
  40                 {
  41                         RaySel.old_numprj[0] = -1;
  42                         RaySel.effcnt = 0; // Bug #214, wei, 11/20/2006
  43                 }
  44
  45                 if (RaySel.effcnt % RaySel.numray == 0)
  46                 {
  47                         RaySel.old_numray[0] = -1;
  48
  49                         pi_map(RaySel.num_digprj, RaySel.decompprj, RaySel.baseprj,
  50                                         &RaySel.old_numprj, &RaySel.new_numprj, &RaySel.curnp);
  51                 }
  52
  53                 pi_map(RaySel.num_digray, RaySel.decompray, RaySel.baseray,
  54                                 &RaySel.old_numray, &RaySel.new_numray, &RaySel.curnr);
  55
  56                 if (!RaySel.useray)
  57                 {
  58                         RaySel.curnr += GeoPar.fsnray; //(GeoPar.nrays-GeoPar.snrays)/2;
  59                 }
  60                 else
  61                 {
  62                         RaySel.curnr += GeoPar.fusray; //(GeoPar.nrays-GeoPar.usrays)/2;
  63                 }
  64
  65                 RaySel.effcnt++;
  66
  67                 break;
  68
  69                 // RANDOM
  70         case 2:
  71                 L30: if (!RaySel.useray)
  72                 {
  73                         RaySel.curnr = (INTEGER) (Rand() * ((REAL) (GeoPar.snrays))
  74                                         + ((REAL) (RaySel.begray))); // bug 184 - swr - 11/04/05
  75                 }
  76                 else
  77                 {
  78                         RaySel.curnr = (INTEGER) (Rand() * ((REAL) (GeoPar.usrays))
  79                                         + ((REAL) (RaySel.begray))); // bug 184 - swr - 11/04/05
  80                 }
  81                 RaySel.curnp = (INTEGER) (Rand() * (REAL) (GeoPar.prjnum)); // bug 184 - swr - 11/04/05
  82                 break;
  83
  84                 // SEQP
  85         case 1:
  86                 L40: RaySel.curnp += RaySel.prjinc;
  87                 if (RaySel.curnp >= GeoPar.prjnum)
  88                 {
  89                         RaySel.curnp = RaySel.initnp;
  90                         RaySel.curnr += RaySel.rayinc;
  91                         if (RaySel.curnr > RaySel.endray)
  92                         {
  93                                 RaySel.initnr++;
  94                                 if (RaySel.initnr
  95                                                 >= MIN0((RaySel.begray + RaySel.rayinc - 1),
  96                                                                 RaySel.endray))
  97                                 {
  98                                         RaySel.initnr = RaySel.begray;
  99                                         RaySel.initnp++;
 100                                         if (RaySel.initnp >= MIN0(RaySel.prjinc, GeoPar.prjnum))
 101                                         {
 102                                                 RaySel.initnp = 0;
 103                                         }
 104                                         RaySel.curnp = RaySel.initnp;
 105                                 }
 106                                 RaySel.curnr = RaySel.initnr;
 107                         }
 108                 }
 109                 break;
 110
 111                 // SEQR
 112         case 0:
 113                 L50: RaySel.curnr += RaySel.rayinc;
 114                 if (RaySel.curnr > RaySel.endray)
 115                 {
 116                         RaySel.curnr = RaySel.initnr;
 117                         RaySel.curnp += RaySel.prjinc;
 118                         if (RaySel.curnp >= GeoPar.prjnum)
 119                         {
 120                                 RaySel.initnp++;
 121                                 if (RaySel.initnp >= MIN0(RaySel.prjinc, GeoPar.prjnum))
 122                                 {
 123                                         RaySel.initnp = 0;
 124                                         RaySel.initnr++;
 125                                         if (RaySel.initnr
 126                                                         >= MIN0((RaySel.begray + RaySel.rayinc - 1),
 127                                                                         RaySel.endray))
 128                                         {
 129                                                 RaySel.initnr = RaySel.begray;
 130                                         }
 131                                         RaySel.curnr = RaySel.initnr;
 132                                 }
 133                                 RaySel.curnp = RaySel.initnp;
 134                         }
 135                 }
 136                 break;
 137
 138                 // (CYCLES) OF RAYS AT RANDOM FOLLOWED BY SEQUENTIAL RAYS
 139         case 3:
 140                 if (RaySel.rcnt1 == RaySel.rn1)
 141                 {
 142                         if (RaySel.rn2 <= 0)
 143                                 goto L50;
 144                         if (RaySel.rcnt2 != RaySel.rn2)
 145                         {
 146                                 RaySel.rcnt2++;
 147                                 goto L50;
 148                         }
 149                         RaySel.rcnt1 = 0;
 150                         RaySel.rcnt2 = 0;
 151                 }
 152                 RaySel.rcnt1++;
 153                 goto L30;
 154
 155                 // (CYCLES) OF RAYS AT RANDOM FOLLOWED BY SEQUENTIAL
 156                 // PROJECTION SELECTION
 157         case 4:
 158                 if (RaySel.rcnt1 == RaySel.rn1)
 159                 {
 160                         if (RaySel.rn2 <= 0)
 161                                 goto L40;
 162                         if (RaySel.rcnt2 != RaySel.rn2)
 163                         {
 164                                 RaySel.rcnt2++;
 165                                 goto L40;
 166                         }
 167                         RaySel.rcnt1 = 0;
 168                         RaySel.rcnt2 = 0;
 169                 }
 170                 RaySel.rcnt1++;
 171                 goto L30;
 172
 173                 // (CYCLES) OF SEQUENTIAL RAYS FOLLOWED BY RAYS AT RANDOM
 174         case 5:
 175                 if (RaySel.rcnt1 == RaySel.rn1)
 176                 {
 177                         if (RaySel.rn2 <= 0)
 178                                 goto L30;
 179                         if (RaySel.rcnt2 != RaySel.rn2)
 180                         {
 181                                 RaySel.rcnt2++;
 182                                 goto L30;
 183                         }
 184                         RaySel.rcnt1 = 0;
 185                         RaySel.rcnt2 = 0;
 186                 }
 187                 RaySel.rcnt1++;
 188                 goto L50;
 189
 190                 // (CYCLES) OF SEQUENTIAL PROJECTION RAYS FOLLOWED BY RAYS AT RANDOM
 191         case 6:
 192                 if (RaySel.rcnt1 == RaySel.rn1)
 193                 {
 194                         if (RaySel.rn2 <= 0)
 195                                 goto L30;
 196                         if (RaySel.rcnt2 != RaySel.rn2)
 197                         {
 198                                 RaySel.rcnt2++;
 199                                 goto L30;
 200                         }
 201                         RaySel.rcnt1 = 0;
 202                         RaySel.rcnt2 = 0;
 203                 }
 204                 RaySel.rcnt1++;
 205                 goto L40;
 206         }
 207
 208         // COMMON RETURN
 209         *np = RaySel.curnp;
 210         *nr = RaySel.curnr;
 211
 212         if (trace > 4)
 213         {
 214                 fprintf(output, "\n          pick    np = %5i  nr = %5i", *np, *nr);
 215         }
 216         return;
 217 }
 218