00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033
00034
00035
00036
#include "experience.h"
00037
#ifdef HAVE_MPI
00038
#include <mpi.h>
00039
#endif
00040
00047 EXPERIENCE3D *
AllocExperience()
00048 {
00049
EXPERIENCE3D * expr;
00050
00051
00052
if ((expr = (
EXPERIENCE3D *) malloc(
sizeof(
EXPERIENCE3D))) == NULL)
00053 {
00054 fprintf(stderr,
"Experience alloc error \n");
00055 exit(1);
00056 }
00057
00058
00059 expr->
name[0]=
'\0';
00060 expr->
nfovx=0; expr->
nfovy=0; expr->
nfovz=0;
00061 expr->
fovx=0; expr->
fovy=0; expr->
fovz=0;
00062 expr->
obx=0; expr->
oby=0; expr->
obz=0;
00063
00064 expr->
ro=NULL;
00065 expr->
t1=NULL;
00066 expr->
t2=NULL;
00067 expr->
sgn=NULL;
00068 expr->
magstate=NULL;
00069
00070 expr->
xf=0.0; expr->
yf=0.0; expr->
zf=0.0;
00071 expr->
px=0.0; expr->
py=0.0; expr->
pz=0.0; expr->
pt=0.0;
00072
00073 expr->
G_deche=NULL;
00074 expr->
deltaB0=NULL;
00075 expr->
G_edw=0.0;
00076
00077 expr->
to=0.0;
00078
00079 expr->
B0=1.0;
00080 expr->
b0def=0.0;
00081
00082 expr->
FLAG_RESONANCE =
ON ;
00083 expr->
FLAG_DECH =
ON ;
00084
return(expr);
00085 }
00086
00087
00094 void FreeExperience(
EXPERIENCE3D *expr)
00095 {
00096
int i,j;
00097
00098
for (i = 0; i < 3; i++) {
00099 free(expr->
sgn[i][0][0]);
00100
for (j = 0; j < expr->
ntx; j++)
00101 free(expr->
sgn[i][j]);
00102 free(expr->
sgn[i]);
00103 }
00104 free(expr->
sgn);
00105
00106
for (i = 0; i < 3; i++) {
00107 free(expr->
magstate[i][0][0]);
00108
for (j = 0; j < expr->
nfovx; j++)
00109 free(expr->
magstate[i][j]);
00110 free(expr->
magstate[i]);
00111 }
00112 free(expr->
magstate);
00113
00114 free(expr->
t1[0][0]);
00115 free(expr->
t2[0][0]);
00116 free(expr->
ro[0][0]);
00117 free(expr->
G_deche[0][0]);
00118 free(expr->
deltaB0[0][0]);
00119
00120
for (i = 0; i < expr->
nfovx; i++) {
00121 free(expr->
t1[i]);
00122 free(expr->
t2[i]);
00123 free(expr->
ro[i]);
00124 free(expr->
G_deche[i]);
00125 free(expr->
deltaB0[i]);
00126 }
00127
00128 free(expr->
t1);
00129 free(expr->
t2);
00130 free(expr->
ro);
00131 free(expr->
G_deche);
00132 free(expr->
deltaB0);
00133
00134 free(expr);
00135 }
00136
00143 void FreeExperienceSgn(
EXPERIENCE3D *expr)
00144 {
00145
int i;
00146
00147
for (i = 0; i < 3; i++) free(expr->
sgn[i]);
00148 free(expr->
sgn);
00149 free(expr);
00150 }
00151
00158 void ResetToExperience(
EXPERIENCE3D *expr)
00159 {
00160 expr->
to=0.0;
00161 }
00162
00169 void InitToExperience(
EXPERIENCE3D *expr)
00170 {
00171 expr->
to=0.0;
00172 }
00173
00182 void SetResonanceExperience(
EXPERIENCE3D *expr,
int flag)
00183 {
00184 expr->
FLAG_RESONANCE=flag;
00185 }
00186
00195 void SetFlagdechExperience(
EXPERIENCE3D *expr,
int flag)
00196 {
00197 expr->
FLAG_DECH=flag;
00198 }
00199
00208 void SetT1Experience(
EXPERIENCE3D *expr, OBJECT3D *object,
int component)
00209 {
00210
int i,j,k;
00211
int l;
00212 l=component*
object->nbparam;
00213
00214
00215
00216
00217
if ((expr->
t1 = (
float ***) malloc(
sizeof(expr->
t1[0]) * expr->
nfovx))
00218 == NULL) {
00219 fprintf(stderr,
"Malloc error in T1 table \n");
00220 exit(1);
00221 }
00222
00223
for (i = 0; i < expr->
nfovx; i++) {
00224
if (
00225 (expr->
t1[i] =
00226 (
float **) malloc(
sizeof(expr->
t1[0][0]) * expr->
nfovy)) ==
00227 NULL) {
00228 fprintf(stderr,
"Malloc error in T1 table \n");
00229 exit(1);
00230 }
00231 }
00232
if (
00233 (expr->
t1[0][0] =
00234 (
float *) malloc(
sizeof(expr->
t1[0][0][0]) * expr->
nfovx *
00235 expr->
nfovy * expr->
nfovz)) == NULL) {
00236 fprintf(stderr,
"Malloc error in T1 table \n");
00237 exit(1);
00238 }
00239
for (i = 0; i < expr->
nfovx; i++)
00240
for (j = 0; j < expr->
nfovy; j++)
00241 expr->
t1[i][j] =
00242 expr->
t1[0][0] + j * expr->
nfovz +
00243 i * expr->
nfovy * expr->
nfovz;
00244
00245
for(i=0;i<expr->
nfovx;i++)
for(j=0;j<expr->
nfovy;j++)
for(k=0;k<expr->
nfovz;k++)
00246 expr->
t1[i][j][k]=
object->values[1+l][k][j][i]/(
float)1000.0;
00247 }
00248
00257 void SetT2Experience(
EXPERIENCE3D *expr, OBJECT3D *object,
int component)
00258 {
00259
int i,j,k;
00260
int l;
00261 l=component*
object->nbparam;
00262
00263
00264
00265
00266
00267
if ((expr->
t2 = (
float ***) malloc(
sizeof(expr->
t2[0]) * expr->
nfovx))
00268 == NULL) {
00269 fprintf(stderr,
"Malloc error in table T2\n");
00270 exit(1);
00271 }
00272
00273
for (i = 0; i < expr->
nfovx; i++) {
00274
if (
00275 (expr->
t2[i] =
00276 (
float **) malloc(
sizeof(expr->
t2[0][0]) * expr->
nfovy)) ==
00277 NULL) {
00278 fprintf(stderr,
"Malloc error in table T2 \n");
00279 exit(1);
00280 }
00281 }
00282
if (
00283 (expr->
t2[0][0] =
00284 (
float *) malloc(
sizeof(expr->
t2[0][0][0]) * expr->
nfovx *
00285 expr->
nfovy * expr->
nfovz)) == NULL) {
00286 fprintf(stderr,
"Malloc error in table T2 \n");
00287 exit(1);
00288 }
00289
for (i = 0; i < expr->
nfovx; i++)
00290
for (j = 0; j < expr->
nfovy; j++)
00291 expr->
t2[i][j] =
00292 expr->
t2[0][0] + j * expr->
nfovz +
00293 i * expr->
nfovy * expr->
nfovz;
00294
00295
for(i=0;i<expr->
nfovx;i++)
for(j=0;j<expr->
nfovy;j++)
for(k=0;k<expr->
nfovz;k++)
00296 expr->
t2[i][j][k]=
object->values[2+l][k][j][i]/(
float)1000.0;
00297 }
00298
00307 void SetRoExperience(
EXPERIENCE3D *expr, OBJECT3D *object,
int component)
00308 {
00309
int i,j,k;
00310
int l;
00311 l=component*
object->nbparam;
00312
00313
00314
00315
00316
00317
if ((expr->
ro = (
float ***) malloc(
sizeof(expr->
ro[0]) * expr->
nfovx))
00318 == NULL) {
00319 fprintf(stderr,
"Malloc error in table Ro\n");
00320 exit(1);
00321 }
00322
00323
for (i = 0; i < expr->
nfovx; i++) {
00324
if (
00325 (expr->
ro[i] =
00326 (
float **) malloc(
sizeof(expr->
ro[0][0]) * expr->
nfovy)) ==
00327 NULL) {
00328 fprintf(stderr,
"Malloc error in table Ro\n");
00329 exit(1);
00330 }
00331 }
00332
if (
00333 (expr->
ro[0][0] =
00334 (
float *) malloc(
sizeof(expr->
ro[0][0][0]) * expr->
nfovx *
00335 expr->
nfovy * expr->
nfovz)) == NULL) {
00336 fprintf(stderr,
"Malloc error in table Ro\n");
00337 exit(1);
00338 }
00339
for (i = 0; i < expr->
nfovx; i++)
00340
for (j = 0; j < expr->
nfovy; j++)
00341 expr->
ro[i][j] =
00342 expr->
ro[0][0] + j * expr->
nfovz +
00343 i * expr->
nfovy * expr->
nfovz;
00344
00345
for(i=0;i<expr->
nfovx;i++)
for(j=0;j<expr->
nfovy;j++)
for(k=0;k<expr->
nfovz;k++)
00346 expr->
ro[i][j][k]=
object->values[0+l][k][j][i];
00347 }
00348
00355 void InitMagstateExperience(
EXPERIENCE3D *expr)
00356 {
00357
int i,j,k,v;
00358
00359
if ((expr->
magstate=(
double ****)malloc(
sizeof(expr->
magstate[0])*3)) ==
00360 NULL) {
00361 fprintf(stderr,
"Malloc error magnetization table\n");
00362 exit(1);
00363 }
00364
00365
for (v = 0; v < 3; v++) {
00366
if (
00367 (expr->
magstate[v] =
00368 (
double ***) malloc(
sizeof(expr->
magstate[0][0]) *
00369 expr->
nfovx)) == NULL) {
00370 fprintf(stderr,
"Malloc error magnetization table\n");
00371 exit(1);
00372 }
00373
00374
for (i = 0; i < expr->
nfovx; i++) {
00375
if (
00376 (expr->
magstate[v][i] =
00377 (
double **) malloc(
sizeof(expr->
magstate[0][0][0]) *
00378 expr->
nfovy)) == NULL) {
00379 fprintf(stderr,
"Malloc error magnetization table\n");
00380 exit(1);
00381 }
00382 }
00383
if (
00384 (expr->
magstate[v][0][0] =
00385 (
double *) malloc(
sizeof(expr->
magstate[0][0][0][0]) *
00386 expr->
nfovx * expr->
nfovy * expr->
nfovz)) ==
00387 NULL) {
00388 fprintf(stderr,
"Malloc error magnetization table\n");
00389 exit(1);
00390 }
00391
for (i = 0; i < expr->
nfovx; i++)
00392
for (j = 0; j < expr->
nfovy; j++)
00393 expr->
magstate[v][i][j] =
00394 expr->
magstate[v][0][0] + j * expr->
nfovz +
00395 i * expr->
nfovy * expr->
nfovz;
00396 }
00397
00398
for(v=0;v<3;v++)
00399
for(i=0;i<expr->
nfovx;i++)
for(j=0;j<expr->
nfovy;j++)
for(k=0;k<expr->
nfovz;k++)
00400 expr->
magstate[v][i][j][k]=0.0;
00401 }
00402
00410 void SetB0Experience(
EXPERIENCE3D *expr,
double B0)
00411 {
00412 expr->
B0 = B0;
00413 }
00414
00422 void SetB0DefExperience(
EXPERIENCE3D *expr,
double valmax)
00423 {
00424 expr->
b0def=valmax;
00425 }
00426
00435 void SetGdechExperience(
EXPERIENCE3D *expr,OBJECT3D *object)
00436 {
00437
int i,j,k;
00438
int x,y,z;
00439
double decx,decy,decz;
00440
float def;
00441
x= expr->
nfovx;
00442 y= expr->
nfovy;
00443 z= expr->
nfovz;
00444
00445
00446
if (
00447 (expr->
G_deche =
00448 (
float ***) malloc(
sizeof(expr->
G_deche[0]) *
x)) ==
00449 NULL) {
00450 fprintf(stderr,
"Malloc error magstate table\n");
00451 exit(1);
00452 }
00453
00454
for (i = 0; i <
x; i++) {
00455
if (
00456 (expr->
G_deche[i] =
00457 (
float **) malloc(
sizeof(expr->
G_deche[0][0]) * y)) == NULL) {
00458 fprintf(stderr,
"Malloc error magstate table \n");
00459 exit(1);
00460 }
00461 }
00462
if (
00463 (expr->
G_deche[0][0] =
00464 (
float *) malloc(
sizeof(expr->
G_deche[0][0][0]) *
x * y * z)) == NULL) {
00465 fprintf(stderr,
"Malloc error G_deche table \n");
00466 exit(1);
00467 }
00468
for (i = 0; i <
x; i++)
for (j = 0; j < y; j++)
00469 expr->
G_deche[i][j] = expr->
G_deche[0][0] + j * z + i * y * z;
00470
00471 decx= expr->
nfovx/2.;
00472 decy= expr->
nfovy/2.;
00473 decz= expr->
nfovz/2.;
00474
00475
00476
switch (expr->
FLAG_DECH)
00477 {
00478
case 0:
00479 {
00480
for (i = 0; i < expr->
nfovx; i++)
00481
for (j = 0; j < expr->
nfovy; j++)
00482
for (k = 0; k < expr->
nfovz; k++)
00483 expr->
G_deche[i][j][k] = 0.0;
00484
break;
00485 }
00486
case 1:
00487 {
00488
for (i = 0; i < expr->
nfovx; i++)
00489
for (j = 0; j < expr->
nfovy; j++)
00490
for (k = 0; k < expr->
nfovz; k++)
00491 expr->
G_deche[i][j][k] = ((
float)expr->
B0)*
object->fielddefault[k][j][i];
00492
break;
00493 }
00494
case 2:
00495 {
00496
for (i = 0; i < expr->
nfovx; i++)
00497
for (j = 0; j < expr->
nfovy; j++)
00498
for (k = 0; k < expr->
nfovz; k++)
00499 expr->
G_deche[i][j][k] = ((
float)expr->
B0)*((i-decx)*(i-decx)+(j-decy)*(j-decy)+(k-decz)*(k-decz))*expr->
b0def/(decx*decx+decy*decy+decz*decz);
00500
break;
00501 }
00502
case 3:
00503 {
00504
for (i = 0; i < expr->
nfovx; i++)
00505
for (j = 0; j < expr->
nfovy; j++)
00506
for (k = 0; k < expr->
nfovz; k++)
00507 {
00508 def =((
float)expr->
B0)*((i-decx)*(i-decx)+(j-decy)*(j-decy)+(k-decz)*(k-decz))*expr->
b0def/(decx*decx+decy*decy+decz*decz);
00509 expr->
G_deche[i][j][k] = def + ((
float)expr->
B0)*
object->fielddefault[k][j][i];
00510 }
00511
break;
00512 }
00513
default:
00514 {
00515
for (i = 0; i < expr->
nfovx; i++)
00516
for (j = 0; j < expr->
nfovy; j++)
00517
for (k = 0; k < expr->
nfovz; k++)
00518 expr->
G_deche[i][j][k] = 0.0;
00519
break;
00520 }
00521 }
00522
00523 }
00524
00533 void SetDeltaB0Experience(
EXPERIENCE3D *expr,OBJECT3D *object)
00534 {
00535
int i,j,k;
00536
int x,y,z;
00537
00538
x= expr->
nfovx;
00539 y= expr->
nfovy;
00540 z= expr->
nfovz;
00541
00542
00543
if (
00544 (expr->
deltaB0 =
00545 (
float ***) malloc(
sizeof(expr->
deltaB0[0]) *
x)) ==
00546 NULL)
00547 {
00548 fprintf(stderr,
"Malloc error of deltaB0 table \n");
00549 exit(1);
00550 }
00551
for (i = 0; i <
x; i++)
00552 {
00553
if ((expr->
deltaB0[i] =
00554 (
float **)malloc(
sizeof(expr->
deltaB0[0][0])*y)) == NULL)
00555 {
00556 fprintf(stderr,
"Malloc error of deltaB0 table\n");
00557 exit(1);
00558 }
00559 }
00560
00561
if ((expr->
deltaB0[0][0] =
00562 (
float *) malloc(
sizeof(expr->
deltaB0[0][0][0])*
x*y*z)) == NULL)
00563 {
00564 fprintf(stderr,
"Malloc error of deltaB0 table\n");
00565 exit(1);
00566 }
00567
for (i=0;i<
x;i++)
for (j=0;j<y;j++)
00568 expr->
deltaB0[i][j] = expr->
deltaB0[0][0] + j * z + i * y * z;
00569
for (i=0;i<
x;i++)
for(j=0;j<y;j++)
for(k=0;k<z;k++)
00570 expr->
deltaB0[i][j][k] = ((
float)expr->
B0) *
object->deltaB0[k][j][i];
00571 }
00572
00584 void SetObjectExperienceComponent(
EXPERIENCE3D *expr, OBJECT3D *object,
int component,
int FLAG_DECH)
00585 {
00586
if ((
object->nbcomponent>2)||(
object->nbparam>4))
00587 {
00588 printf(
"This kind of object is not manageable at the moment!\n");
00589 exit(0);
00590 }
00591
00592
00593
if(component==0) expr->
G_edw =
object->chemshift[
WATER] * 2. * M_PI ;
00594
else
00595
if(component==1) expr->
G_edw =
object->chemshift[
FAT] * 2. * M_PI;
00596
else
00597 {
00598 printf(
"Component not defined !\n");
00599 exit(1);
00600 }
00601
00602 expr->
FLAG_DECH = FLAG_DECH ;
00603
00604
00605
00606 expr->
lx =
object->lx;
00607 expr->
ly =
object->ly;
00608 expr->
lz =
object->lz;
00609 expr->
fovx =
object->lx;
00610 expr->
fovy =
object->ly;
00611 expr->
fovz =
object->lz;
00612
00613
00614 expr->
nfovx=
object->x;
00615 expr->
nfovy=
object->y;
00616 expr->
nfovz=
object->z;
00617
00618
00619
00620 expr->
px = expr->
nfovx == 1 ? 1e-12 : expr->
lx / (expr->
nfovx - 1);
00621 expr->
py = expr->
nfovy == 1 ? 1e-12 : expr->
ly / (expr->
nfovy - 1);
00622 expr->
pz = expr->
nfovz == 1 ? 1e-12 : expr->
lz / (expr->
nfovz - 1);
00623 expr->
xf = expr->
lx / 2.;
00624 expr->
yf = expr->
ly / 2.;
00625 expr->
zf = expr->
lz / 2.;
00626
00627
00628
InitToExperience(expr);
00629
SetT1Experience(expr,
object,component);
00630
SetT2Experience(expr,
object,component);
00631
SetRoExperience(expr,
object,component);
00632
InitMagstateExperience(expr);
00633
SetDeltaB0Experience(expr,
object);
00634
SetGdechExperience(expr,
object);
00635 }
00636
00637
00645 void SetNameExperience(
EXPERIENCE3D *expr,
char *name)
00646 {
00647 strcpy(expr->
name,name);
00648 }
00649
00656 void InitRFSigExperience(
EXPERIENCE3D *expr)
00657 {
00658
int i,j,k,v;
00659
00660
00661
00662
00663
if ((expr->
sgn = (
float ****) malloc(
sizeof(
float ***) * 3)) == NULL) {
00664 fprintf(stderr,
"Malloc error of the RF signal table\n");
00665 exit(1);
00666 }
00667
00668
for (v = 0; v < 3; v++) {
00669
if (
00670 (expr->
sgn[v] =
00671 (
float ***) malloc(
sizeof(
float **) * expr->
ntx)) == NULL) {
00672 fprintf(stderr,
"Malloc error of the RF signal table \n");
00673 exit(1);
00674 }
00675
00676
for (i = 0; i < expr->
ntx; i++) {
00677
if (
00678 (expr->
sgn[v][i] =
00679 (
float **) malloc(
sizeof(
float *) * expr->
nty)) == NULL) {
00680 fprintf(stderr,
"Malloc error of the RF signal table \n");
00681 exit(1);
00682 }
00683 }
00684
if (
00685 (expr->
sgn[v][0][0] =
00686 (
float *) malloc(
sizeof(
float) * expr->
ntx * expr->
nty *
00687 expr->
ntz)) == NULL) {
00688 fprintf(stderr,
"Malloc error of the RF signal table\n");
00689 exit(1);
00690 }
00691
for (i = 0; i < expr->
ntx; i++)
00692
for (j = 0; j < expr->
nty; j++)
00693 expr->
sgn[v][i][j] =
00694 expr->
sgn[v][0][0] + j * expr->
ntz +
00695 i * expr->
nty * expr->
ntz;
00696 }
00697
00698
for (i = 0; i < expr->
ntx; i++)
00699
for (j = 0; j < expr->
nty; j++)
00700
for (k = 0; k < expr->
ntz; k++) {
00701 expr->
sgn[0][i][j][k] = 0;
00702 expr->
sgn[1][i][j][k] = 0;
00703 expr->
sgn[2][i][j][k] = 0;
00704 }
00705 }
00706
00718 void SetAcqExperience (
EXPERIENCE3D *expr,
int ntx,
int nty,
int ntz,
00719
double tacq)
00720 {
00721
00722 expr->
ntx = ntx;
00723 expr->
nty = nty;
00724 expr->
ntz = ntz;
00725
if (tacq == 0) {
00726 fprintf(stderr,
"Error : acquisition time equals zero\n");
00727 exit(1);
00728 }
00729
else
00730 expr->
readout_time = tacq;
00731
00732 expr->
pt = expr->
readout_time / (expr->
ntx - 1);
00733
InitRFSigExperience(expr);
00734 }
00735
00736
00746 EXPERIENCE3D *
AllocExperienceSgn(
int ntx,
int nty,
int ntz)
00747 {
00748
EXPERIENCE3D * expr;
00749
00750 expr =
AllocExperience();
00751 expr->
ntx = ntx;
00752 expr->
nty = nty;
00753 expr->
ntz = ntz;
00754
00755
InitRFSigExperience(expr);
00756
return(expr);
00757 }
00758
00771 void SetFovExperience (
EXPERIENCE3D *expr,
double fovx,
00772
double fovy,
double fovz,
00773
double obx,
double oby,
00774
double obz)
00775 {
00776 expr->
fovx = fovx;
00777 expr->
fovy = fovy;
00778 expr->
fovz = fovz;
00779 expr->
obx = obx;
00780 expr->
oby = oby;
00781 expr->
obz = obz;
00782 }
00783
00791 PPPVOLUME_COMPLEX_DOUBLE GetSignalRFComplexFromExperience(
EXPERIENCE3D *expr)
00792 {
00793
PPPVOLUME_COMPLEX_DOUBLE volcomplex;
00794
int i,j,k;
00795
int x,y,z;
00796
#ifdef HAVE_MPI
00797
int myrank;
00798
#endif
00799
00800
x= expr->
ntx;
00801 y= expr->
nty;
00802 z= expr->
ntz;
00803
00804 volcomplex = (
PPPVOLUME_COMPLEX_DOUBLE)
IdVolAlloc(
x,y,z,
VOL_COMPLEX_DOUBLE);
00805
00806
for (k=0;k<z;k++)
for(j=0;j<y;j++)
for(i=0;i<
x;i++)
00807 {
00808 volcomplex[k][j][i].
re = expr->
sgn[1][i][j][k];
00809 volcomplex[k][j][i].
im = expr->
sgn[0][i][j][k];
00810 }
00811
#ifdef HAVE_MPI
00812
MPI_Comm_rank(MPI_COMM_WORLD, &myrank);
00813
if (myrank == 0) {
00814
float avg[2]={0.,0.};
00815
float min[2]={0.,0.};
00816
float max[2]={0.,0.};
00817
float std_dev[2]={0.,0.};
00818
float e[2];
00819
int l;
00820
00821
min[0] =
max[0] = expr->
sgn[0][0][0][0];
00822
min[1] =
max[1] = expr->
sgn[1][0][0][0];
00823
for (i=0;i<
x;i++)
00824
for (j=0;j<y;j++)
00825
for (k=0;k<z;k++)
00826
for (l=0;l<2;l++) {
00827 e[l] = expr->
sgn[l][i][j][k];
00828 avg[l] += e[l];
00829
00830
if (e[l] >
max[l])
max[l]=e[l];
00831
if (e[l] <
min[l])
min[l]=e[l];
00832 }
00833 avg[0] = avg[0] / (
x*y*z);
00834 avg[1] = avg[1] / (
x*y*z);
00835
00836
for (i=0;i<
x;i++)
00837
for (j=0;j<y;j++)
00838
for (k=0;k<z;k++)
00839
for (l=0;l<2;l++) {
00840 e[l] = expr->
sgn[l][i][j][k];
00841 std_dev[l] += (e[l] - avg[l])*(e[l] - avg[l]);
00842 }
00843 std_dev[0] = sqrt(std_dev[0] / (
x*y*z));
00844 std_dev[1] = sqrt(std_dev[1] / (
x*y*z));
00845
00846 printf(
"summary:\n");
00847 printf(
"im: min=%f, max=%f, avg=%f, std_dev=%f\n",
00848
min[0],
max[0], avg[0], std_dev[0]);
00849 printf(
"re: min=%f, max=%f, avg=%f, std_dev=%f\n",
00850
min[1],
max[1], avg[1], std_dev[1]);
00851 }
00852
#endif
00853
00854
return (volcomplex);
00855 }
00856
00863 void NormalizeRFSignal(
EXPERIENCE3D *expr)
00864 {
00865
int i,j,k,n;
00866
int x,y,z;
00867
double c;
00868
00869
00870 c = expr->
px * expr->
py * expr->
pz;
00871
x= expr->
ntx; y= expr->
nty; z= expr->
ntz;
00872
00873
for(k=0;k<z;k++)
for(j=0;j<y;j++)
for(i=0;i<
x;i++)
for (n=0;n<3;n++)
00874 expr->
sgn[n][i][j][k] = expr->
sgn[n][i][j][k] / (
float) c;
00875 }
00876
00885 PPPVOLUME_FLOAT GetSignalRFComponentFromExperience(
EXPERIENCE3D *expr,
int comp)
00886 {
00887
PPPVOLUME_FLOAT vol;
00888
register int i,j,k;
00889
int x,y,z;
00890
00891
if ((comp >2) || (comp<0))
00892 {
00893 printf(
"This component does not exist!\n");
00894 exit(1);
00895 }
00896
00897
x= expr->
ntx; y= expr->
nty; z= expr->
ntz;
00898
00899 vol = (
PPPVOLUME_FLOAT)
IdVolAlloc(
x,y,z,
VOL_FLOAT);
00900
for(k=0;k<z;k++)
for(j=0;j<y;j++)
for(i=0;i<
x;i++)
00901 vol[k][j][i] = (
float) expr->
sgn[comp][i][j][k];
00902
00903
return (vol);
00904 }
00905
00915 PPIMAGE_UCHAR GetkSpaceImage2DFromExperience(
EXPERIENCE3D *expr,
int haut,
int dir)
00916 {
00917
PPIMAGE_FLOAT imafloat;
00918
PSIGNAL_FLOAT sigx;
00919
PPIMAGE_UCHAR imasig;
00920
PPIMAGE_UCHAR ima;
00921
int i,j;
00922
int x,y,z;
00923
int ligne;
00924
00925
x= expr->
ntx;
00926 y= expr->
nty;
00927 z= expr->
ntz;
00928
00929
if (z!=1)
00930 {
00931 printf(
"Only available for 2D k space \n");
00932 exit(1);
00933 }
00934
00935
if (!((dir ==0) || (dir==1)))
00936 {
00937 printf(
"The direction parameter is not correct : 0->X, 1->Y \n");
00938 exit(1);
00939 }
00940
00941
00942 imafloat = (
PPIMAGE_FLOAT)
IdImaAlloc(
x,y,
IMA_FLOAT);
00943
for(j=0;j<y;j++)
for(i=0;i<
x;i++)
00944 imafloat[j][i] = expr->
sgn[dir][i][j][0];
00945
00946 ima = (
PPIMAGE_UCHAR)
IdImaAlloc(
x,y*haut,
IMA_UCHAR);
00947
for(ligne=0;ligne<y;ligne++)
00948 {
00949 sigx = (
PSIGNAL_FLOAT)
IdSigAlloc(
x,
SIG_FLOAT);
00950
for (i=0;i<
x;i++) sigx[i] = imafloat[ligne][i];
00951 imasig =
IdImaSignalToImage(sigx,0,
x,0,-1,-1,
x,haut,255,0);
00952
for(i=0;i<
x;i++)
for (j=0;j<haut;j++)
00953 ima[(ligne*haut)+j][i] = imasig[j][i];
00954
IdImaFree(imasig);
00955 }
00956
00957
IdSigFree(sigx);
00958
IdImaFree(imafloat);
00959
00960
return (ima);
00961 }
00962
00963
00971 PPPVOLUME_FLOAT GetSignalRFModuleFromExperience(
EXPERIENCE3D *expr)
00972 {
00973
PPPVOLUME_COMPLEX_DOUBLE volcomplex;
00974
PPPVOLUME_FLOAT module;
00975
register int i,j,k;
00976
int x,y,z;
00977
double a,
b;
00978
00979
x= expr->
ntx;
00980 y= expr->
nty;
00981 z= expr->
ntz;
00982
00983 volcomplex = (
PPPVOLUME_COMPLEX_DOUBLE)
GetSignalRFComplexFromExperience (expr);
00984
00985 module = (
PPPVOLUME_FLOAT)
IdVolAlloc(
x,y,z,
VOL_FLOAT);
00986
for(k=0;k<z;k++)
for(j=0;j<y;j++)
for(i=0;i<
x;i++)
00987 {
00988 a = volcomplex[k][j][i].
re;
00989
b = volcomplex[k][j][i].im;
00990 module[k][j][i] = (
float) sqrt(a*a +
b*
b);
00991 }
00992
00993
IdVolFree(volcomplex);
00994
return (module);
00995 }
00996
01004 PPPVOLUME_FLOAT GetSignalRFPhaseFromExperience(
EXPERIENCE3D *expr)
01005 {
01006
PPPVOLUME_COMPLEX_DOUBLE volcomplex;
01007
PPPVOLUME_FLOAT phase;
01008
register int i,j,k;
01009
int x,y,z;
01010
double a,
b;
01011
01012
x= expr->
ntx;
01013 y= expr->
nty;
01014 z= expr->
ntz;
01015
01016 volcomplex = (
PPPVOLUME_COMPLEX_DOUBLE)
GetSignalRFComplexFromExperience (expr);
01017
01018 phase = (
PPPVOLUME_FLOAT)
IdVolAlloc(
x,y,z,
VOL_FLOAT);
01019
for(k=0;k<z;k++)
for(j=0;j<y;j++)
for(i=0;i<
x;i++)
01020 {
01021 a = volcomplex[k][j][i].
re;
01022
b = volcomplex[k][j][i].im;
01023 phase[k][j][i] = (
float) atan(
b/a);
01024 }
01025
01026
IdVolFree(volcomplex);
01027
return (phase);
01028 }
01029
01038 EXPERIENCE3D *
GetSumSignalRFComplex(
PPPVOLUME_COMPLEX_DOUBLE volrf_1,
01039
PPPVOLUME_COMPLEX_DOUBLE volrf_2 )
01040 {
01041
int i,j,k;
01042
int x,y,z;
01043
EXPERIENCE3D * expr;
01044
01045
x=
IdVolDimX(volrf_1);
01046 y=
IdVolDimY(volrf_1);
01047 z=
IdVolDimZ(volrf_1);
01048
01049 expr=
AllocExperienceSgn(
x,y,z);
01050
01051
for (k=0;k<z;k++)
for(j=0;j<y;j++)
for(i=0;i<
x;i++)
01052 {
01053
01054 expr->
sgn[1][i][j][k]= (
float)(volrf_1[k][j][i].
re + volrf_2[k][j][i].
re);
01055 expr->
sgn[0][i][j][k]= (
float)(volrf_1[k][j][i].
im + volrf_2[k][j][i].
im);
01056 }
01057 expr->
ntx=
x;
01058 expr->
nty=y;
01059 expr->
ntz=z;
01060
01061
return (expr);
01062 }
01063
01072 EXPERIENCE3D *
GetDiffSignalRFComplex(
PPPVOLUME_COMPLEX_DOUBLE volrf_1,
01073
PPPVOLUME_COMPLEX_DOUBLE volrf_2)
01074 {
01075
int i,j,k;
01076
int x,y,z;
01077
EXPERIENCE3D * expr;
01078
01079
x=
IdVolDimX(volrf_1);
01080 y=
IdVolDimY(volrf_1);
01081 z=
IdVolDimZ(volrf_1);
01082
01083 expr=
AllocExperienceSgn(
x,y,z);
01084
01085
for (k=0;k<z;k++)
for(j=0;j<y;j++)
for(i=0;i<
x;i++)
01086 {
01087 expr->
sgn[1][i][j][k]= (
float)(volrf_1[k][j][i].
re - volrf_2[k][j][i].
re);
01088 expr->
sgn[0][i][j][k]= (
float)(volrf_1[k][j][i].
im - volrf_2[k][j][i].
im);
01089 }
01090
01091 expr->
ntx=
x;
01092 expr->
nty=y;
01093 expr->
ntz=z;
01094
01095
return (expr);
01096 }
01097
01105 void AddComplexVolRF(
PPPVOLUME_COMPLEX_DOUBLE volacu,
PPPVOLUME_COMPLEX_DOUBLE vol)
01106 {
01107
int x,y,z;
01108
int i,j,k;
01109
01110
if ((!volacu) || (!vol))
01111 {
01112
FPRINTF(stderr,
"Volumes to add not allocated !!\n");
01113 exit(0);
01114 }
01115
01116
x =
IdVolDimX(volacu);
01117 y =
IdVolDimY(volacu);
01118 z =
IdVolDimZ(volacu);
01119
01120
if ((
x!=
IdVolDimX(vol))||(y!=
IdVolDimY(vol))||(z!=
IdVolDimZ(vol)))
01121 {
01122
FPRINTF(stderr,
"Volumes to add have differents sizes !!\n");
01123 exit(0);
01124 }
01125
01126
for(i=0;i<
x;i++)
for (j=0;j<y;j++)
for (k=0;k<z;k++)
01127 {
01128 volacu[k][j][i].
re = volacu[k][j][i].
re + vol[k][j][i].
re;
01129 volacu[k][j][i].
im = volacu[k][j][i].
im + vol[k][j][i].
im;
01130 }
01131 }
01132