lib/src1/brukerdataset.cpp

   1 //
   2 // C++ Implementation: brukerdataset
   3 //
   4 // Description:
   5 //
   6 //
   7 // Author:  <Denis Grenier>, (C) 2008
   8 //
   9 // Copyright: See COPYING file that comes with this distribution
  10 //
  11 //
  12
  13
  14 #define DEBUG 0
  15
  16 #include "brukerdataset.h"
  17
  18 BrukerDataSet::BrukerDataSet(){}
  19
  20
  21 BrukerDataSet::~BrukerDataSet(){}
  22
  23
  24 bool BrukerDataSet::LoadFile(std::string& fileToRead)
  25 {
  26
  27 //std::cout <<
  28 //"------------- BrukerDataSet::LoadFile() Open : [" << fileToRead << "]" << std::endl;
  29   std::ifstream FID;
  30   char * buffer;
  31   FID.open(fileToRead.c_str(), std::ios::binary);
  32   if (FID.rdstate()==std::ios::failbit) {
  33     //std::cout << "BrukerDataSet::LoadFile() Cannot open : [" << fileToRead << "]" << std::endl;
  34     return false;
  35   }
  36
  37   FID.seekg (0, std::ios::end);
  38   int length = FID.tellg();
  39   FID.seekg (0, std::ios::beg);
  40
  41   buffer = new char [length];
  42   FID.read (buffer,length);
  43   FID.close();
  44   BrukerDataSet::WholeHeader=buffer;
  45   delete [] buffer;
  46   return true;
  47 }
  48
  49
  50
  51 std::string BrukerDataSet::SearchBufferForText(std::string& file, const boost::regex& RegExp)
  52 {
  53   boost::cmatch what;
  54   if (regex_search(file.c_str(), what, RegExp))
  55     return what[1];
  56   return "";
  57 }
  58
  59
  60 /**
  61  *
  62  * @param file
  63  * @param RegExp
  64  * @return bool
  65  */
  66 bool BrukerDataSet::BoolMatchBufferForText(std::string& file, const boost::regex& RegExp)
  67 {
  68   boost::cmatch what;
  69   if (regex_match(file.c_str(), what, RegExp))
  70     return true;
  71   return false;
  72 }
  73
  74
  75
  76 std::string BrukerDataSet::MatchBufferForText(std::string& file,const boost::regex& RegExp)
  77 {
  78   boost::cmatch what;
  79   if (regex_match(file.c_str(), what, RegExp))
  80     return what[1];
  81   return "";
  82 }
  83
  84
  85
  86 std::string BrukerDataSet::GetKeyword(std::string& file)
  87 {
  88   return MatchBufferForText( file,KeyWord);
  89 }
  90
  91
  92
  93 int BrukerDataSet::GetDimensionnality(std::string& file)
  94 {
  95   int iterator=0;
  96   std::string DimensionnalityBuffer=SearchBufferForText(file,Dimensionnality);
  97   if (DimensionnalityBuffer=="")
  98     return iterator;
  99   boost::match_results<std::string::const_iterator> what;
 100   boost::match_flag_type flags= boost::match_default;
 101   std::string::const_iterator start,end;
 102   start=DimensionnalityBuffer.begin();
 103   end=DimensionnalityBuffer.end();
 104
 105   while (regex_search(start, end, what, UnsignedInteger))
 106   {
 107     iterator++;
 108     start=what[0].second;
 109     flags |= boost::match_prev_avail;
 110     flags |= boost::match_not_bob;
 111   }
 112   return iterator;
 113 }
 114
 115
 116
 117 int BrukerDataSet::GetIntValueOfDimN(std::string& file, int N)
 118 {
 119   int iterator=0;
 120   std::string DimensionnalityBuffer=SearchBufferForText(file,Dimensionnality);
 121   if (N < 1 || DimensionnalityBuffer=="")
 122     return 0;
 123   //std::cout << DimensionnalityBuffer << std::endl;
 124   boost::match_results<std::string::const_iterator> what;
 125   boost::match_flag_type flags= boost::match_default;
 126   std::string::const_iterator start,end;
 127   start=DimensionnalityBuffer.begin();
 128   end=DimensionnalityBuffer.end();
 129
 130   for (int i=1;i<=N;i++)
 131   {
 132     regex_search(start,end, what, UnsignedInteger);
 133     iterator++;
 134     start=what[0].second;
 135     flags |= boost::match_prev_avail;
 136     flags |= boost::match_not_bob;
 137   }
 138   return atoi(std::string(what[1].first,what[1].second).c_str());
 139 }
 140
 141
 142
 143 std::string BrukerDataSet::GetValuesPart(std::string& file)
 144 {
 145   std::string Result;
 146   Result=MatchBufferForText(file,BufferNValues);
 147   if (Result !="")
 148     return Result;
 149   return MatchBufferForText(file,Buffer1Value);
 150 }
 151
 152
 153 std::string BrukerDataSet::GetContentType(std::string& file)
 154 {
 155   std::string ValuesPart, Result;
 156   ValuesPart=GetValuesPart(file);
 157   if (BoolMatchBufferForText(ValuesPart,IntSeries))
 158     return "int";
 159   if (BoolMatchBufferForText(ValuesPart,FloatSeries))
 160     return "float";
 161   return "string";
 162 }
 163
 164
 165
 166 int BrukerDataSet::GetIntValueN(std::string& file,int N)
 167 {
 168   std::string ValuesPart=GetValuesPart(file);
 169   int iterator=0;
 170   if (N < 1 || ValuesPart=="")
 171     return -32767;
 172
 173   boost::match_results<std::string::const_iterator> what;
 174   boost::match_flag_type flags= boost::match_default;
 175   std::string::const_iterator start,end;
 176   start=ValuesPart.begin();
 177   end=ValuesPart.end();
 178
 179   while (iterator != N)
 180   {
 181     regex_search(start,end, what, SignedInteger);
 182     iterator++;
 183     start=what[0].second;
 184     flags |= boost::match_prev_avail;
 185     flags |= boost::match_not_bob;
 186   }
 187   return (atoi((std::string(what[1].first,what[1].second)).c_str()));
 188 }
 189
 190
 191
 192 double BrukerDataSet::GetDoubleValueN(std::string& file, int N)
 193 {
 194   std::string ValuesPart=GetValuesPart(file);
 195   int iterator=0;
 196   if (N < 1 || ValuesPart=="")
 197     return 0;
 198   boost::match_results<std::string::const_iterator> what;
 199   boost::match_flag_type flags= boost::match_default;
 200   std::string::const_iterator start,end;
 201   start=ValuesPart.begin();
 202   end=ValuesPart.end();
 203
 204   while (iterator != N)
 205   {
 206     regex_search(start,end, what, IntOrFloat);
 207     iterator++;
 208     start=what[0].second;
 209     flags |= boost::match_prev_avail;
 210     flags |= boost::match_not_bob;
 211   }
 212   return (atof((std::string(what[1].first,what[1].second)).c_str()));
 213 }
 214
 215
 216
 217 std::string BrukerDataSet::GetTextValueN(std::string& file, int N)
 218 {
 219   return GetValuesPart(file);
 220 }
 221
 222
 223
 224 int BrukerDataSet::GetKeywordNumberOfElements(std::string& file)
 225 {
 226   int NumberOfElements=1;
 227   for (int i=1;i<=GetDimensionnality(file);i++)
 228       NumberOfElements*=GetIntValueOfDimN(file, i);
 229   return NumberOfElements;
 230 }
 231
 232
 233
 234 /**
 235  *
 236 @fn bool BrukerDataSet::FillMap()
 237 @brief This method fills the Bruker headermap with everything contained in the acqp file
 238
 239 The map is made of BrukerFieldData containing the keywords:
 240 Datatype (string, int, double)
 241 DimensionNumber: The number of Dimensions of the keyword-> 0 scalar, 1-> 1D-vector, 2-> 2D-Matrix, 3->3D-Matrix, ...
 242 DimensionNumberValue: Gives the size of each dimension
 243 DoubleValue: return a vector of values if they are of type double
 244 IntValue: return a vector of values if they are of type int
 245 StringValue: return a string if the values where not identified as a serie of numbers
 246 NumberOfElements: Number of elements corresponding to the keyword given
 247  * @return bool
 248  */
 249 bool BrukerDataSet::FillMap()
 250 {
 251
 252   std::string ValuesBuffer, Keyword,TempString, Substring;
 253   int   i;
 254   int KeywordNumber=0;
 255   int PositionDebut=WholeHeader.find("##");
 256   int PositionFin=PositionDebut+2;
 257   int PosRel;
 258   BrukerFieldData data;
 259   if (PositionFin>=WholeHeader.length())
 260     return false;
 261
 262   while(PositionDebut!=std::string::npos)
 263   {
 264     PositionFin=WholeHeader.find("##",PositionDebut+2);
 265     if (-1 == PositionFin) break ;
 266     Substring=WholeHeader.substr (PositionDebut,PositionFin-PositionDebut-1);
 267     PosRel=Substring.find("$$",0);
 268     if (-1 != PosRel) Substring=Substring.substr (0,PosRel-1);
 269
 270
 271     if (DEBUG) std::cout<<"Substring=[" << Substring << "]" <<std::endl;
 272
 273     PositionDebut=PositionFin;
 274     Keyword=GetKeyword(Substring);
 275     if (DEBUG) std::cout<<"Keyword="<< Keyword <<std::endl;
 276     data.DimensionNumber=GetDimensionnality(Substring);
 277     if (DEBUG) std::cout<<"data.DimensionNumber="<< data.DimensionNumber <<std::endl;
 278
 279     data.DataType=GetContentType(Substring);
 280     if (DEBUG) std::cout<<"data.DataType="<< data.DataType <<std::endl;
 281     data.NumberOfElements=GetKeywordNumberOfElements(Substring);
 282     if(data.DataType=="string")
 283       data.DimensionNumber=0;
 284     if(data.DataType=="string")
 285       data.NumberOfElements=1;
 286     if (DEBUG) std::cout<<"data.NumberOfElements="<< data.NumberOfElements <<std::endl;
 287
 288     i=0;
 289     while (i<=data.DimensionNumber)
 290     {
 291       data.DimensionNumberValue.push_back(GetIntValueOfDimN(Substring,i));
 292       if (DEBUG) std::cout<<"data.DimensionNumberValue["<<i<<"]="<< data.DimensionNumberValue[i] <<std::endl;
 293       i++;
 294     }
 295
 296     if (DEBUG) std::cout<< "data= ";
 297
 298     for(i =1;i<=data.NumberOfElements;i++)
 299     {
 300
 301       if (data.DataType=="int")
 302       {
 303         data.IntValue.push_back(GetIntValueN(Substring,i));
 304         data.DoubleValue.push_back((double) GetIntValueN(Substring,i));
 305         if (DEBUG) std::cout<< data.IntValue[i-1]<<" ";
 306       }
 307
 308       if (data.DataType=="float")
 309       {
 310         data.DoubleValue.push_back(GetDoubleValueN(Substring,i));
 311         if (DEBUG) std::cout<< data.DoubleValue[i-1]<<" ";
 312       }
 313     }
 314
 315     if (data.DataType=="string")
 316     {
 317       data.StringValue.push_back(GetTextValueN(Substring,0));
 318       if (DEBUG) std::cout<< "[" << data.StringValue[0]<<"] ";
 319     }
 320
 321      if (DEBUG) std::cout<< std::endl  << "---- " <<std::endl;
 322
 323     BrukerDataSet::BrukerHeaderMap[ Keyword ] = data;
 324     data.DimensionNumberValue.clear();
 325     data.IntValue.clear();
 326     data.DoubleValue.clear();
 327     data.StringValue.clear();
 328     data.DataType.clear();
 329     KeywordNumber++;
 330     //std::cout<<std::endl;
 331   }
 332   return true;
 333 }
 334
 335
 336 void BrukerDataSet::PrintKey(std::string & KeyWord)
 337 {
 338   int i;
 339   if(!BrukerDataSet::CheckExistKeyword(KeyWord))
 340   {
 341     std::cout<< "KeyWord = "<<KeyWord <<" doesn't exist !"<<std::endl;
 342   }
 343   else
 344   {
 345     std::cout<< "KeyWord = "<<KeyWord <<std::endl;
 346     BrukerDataSet::BrukerHeaderMap[ KeyWord ].PrintSelf();
 347
 348   }
 349 }
 350
 351
 352
 353 void BrukerDataSet::PrintSelf()
 354 {
 355    BrukMapType::iterator it;
 356    for (it=  BrukerHeaderMap.begin();
 357          it !=  BrukerHeaderMap.end();
 358        ++it )
 359     {
 360        std::cout << std::endl << "-----------------[" <<(*it).first << "]" << std::endl;
 361        std::string a =  (*it).first;
 362        PrintKey(a);
 363     }
 364 }
 365
 366
 367 bool BrukerDataSet::CheckExistKeyword(std::string &KeyWord)
 368 {
 369  BrukMapType::iterator element;
 370   element = BrukerHeaderMap.find(KeyWord);
 371   if (element != BrukerHeaderMap.end() )
 372     return true;
 373   return false;
 374 }
 375
 376 bool BrukerDataSet::CheckExistKeyword(const char *KeyWord)
 377 {
 378 std::string temp(KeyWord);
 379 BrukerDataSet::CheckExistKeyword(temp);
 380     return true;
 381 }
 382
 383
 384 const BrukerFieldData& BrukerDataSet::GetFieldData(std::string & kw)
 385 {
 386    return BrukerHeaderMap[kw];
 387 }
 388
 389 const BrukerFieldData& BrukerDataSet::GetFieldData(const char *kw)
 390 {
 391    std::string str_kw(kw);
 392    return BrukerHeaderMap[str_kw];
 393 }
 394
 395
 396 bool BrukerDataSet::Getkspace(std::string &FileToRead)
 397 {
 398   std::string GO_raw_data_format("GO_raw_data_format");
 399   if (!CheckExistKeyword(GO_raw_data_format))
 400     return false;
 401   std::ifstream FID;
 402
 403   FID.open(FileToRead.c_str(), std::ios::binary);
 404   if (FID.rdstate()==std::ios::failbit)
 405     return false;
 406   FID.seekg (0, std::ios::end);
 407   long length = FID.tellg();
 408   FID.seekg (0, std::ios::beg);
 409   long NumberOfValues;
 410
 411
 412   if (GetTextValueN(GO_raw_data_format,1)=="GO_32BIT_SGN_INT")
 413     NumberOfValues=length/4;
 414   if (GetTextValueN(GO_raw_data_format,1)=="GO_16BIT_SGN_INT")
 415     NumberOfValues=length/2;
 416   if (GetTextValueN(GO_raw_data_format,1)=="GO_32BIT_FLOAT")
 417     NumberOfValues=length/4;
 418
 419   char * buffer;
 420   buffer = new char[length];
 421
 422   FID.read (buffer,length);
 423   FID.close();
 424 //for (long i=0;i<NumberOfValues;i++) BrukerDataSet::WholeKspace.pushback(buffer[i]);
 425   delete [] buffer;
 426   return true;
 427 }
 428
 429
 430 std::vector< int > BrukerDataSet::GetLoopStructure() const
 431 {
 432    return LoopStructure;
 433 }
 434
 435 /**
 436     @fn bool BrukerDataSet::SetLoopStructure (const std::vector<int> & theValue )
 437  * @brief this methods provide a way to inject a userdefined loop structure, be very aware that this method is not foolproof
 438  * @param theValue
 439  * @return bool
 440  */
 441 bool BrukerDataSet::SetLoopStructure ( const std::vector<int> & theValue )
 442 {
 443    LoopStructure = theValue;
 444    return true;
 445 }
 446
 447
 448 /**
 449    @fn bool BrukerDataSet::SetLoopStructureOld ( )
 450  * @brief method to set the default Bruker loopstructure (not yet able to deal with EPI, SPIRAL or spectroscopic experiments
 451  * @return bool
 452  * @todo  implement multicoil version
 453  */
 454 bool BrukerDataSet::SetLoopStructureOld ()
 455 {
 456    LoopStructure.clear();
 457 /*
 458 \file brukerdataset.cpp
 459 \fn bool BrukerDataSet::setGenericLoopStructure ( )
 460 \brief sets the loop structure of a standard Bruker experiment
 461
 462 NR                               (Nbre de repetitions)
 463    NILoop                        (Boucle eventuelle extra (Diffusion par exemple) si NI<>(NSLICES x NECHOES) cette boucle est a� NI/(NSLICES x NECHOES)
 464                                  (Attention NILoop peut masquer plusieurs boucles imbriquees !!!!!)
 465       ACQ_size[1..M]             (Codage suivant les autres dimensions)
 466          NSLICES                 (Nombre de tranches)
 467             ACQ_phase_factor     (Facteur turbo de la sequence)
 468                ACQ_ns_list_size  (Nombre d'echos)
 469                   ACQ_size[0]    (Ligne acq reelle)
 470
 471 */
 472
 473
 474    std::string NRStr("NR");
 475    std::string NIStr("NI");
 476    std::string ACQ_sizeStr("ACQ_size");
 477    std::string ACQ_phase_factorStr("ACQ_phase_factor");
 478    std::string ACQ_ns_listStr("ACQ_ns_list");
 479    std::string ACQ_ns_list_sizeStr("ACQ_ns_list_size");
 480    std::string NSLICESStr("NSLICES");
 481
 482    int  i, temp;
 483    std::vector<int> TempIntVect;
 484    TempIntVect.clear();
 485
 486    if (! CheckExistKeyword(NRStr))              return false;
 487    if (! CheckExistKeyword(NIStr))              return false;
 488    if (! CheckExistKeyword(ACQ_sizeStr))        return false;
 489    if (! CheckExistKeyword(ACQ_phase_factorStr))return false;
 490    if (! CheckExistKeyword(ACQ_ns_list_sizeStr))return false;
 491    if (! CheckExistKeyword(NSLICESStr))         return false;
 492
 493    TempIntVect.push_back(BrukerDataSet::BrukerHeaderMap[ (std::string)  "ACQ_size" ].IntValue[0]);
 494    TempIntVect.push_back(BrukerDataSet::BrukerHeaderMap[(std::string)  "ACQ_ns_list_size"].IntValue[0]);
 495    TempIntVect.push_back(BrukerDataSet::BrukerHeaderMap[(std::string)  "ACQ_phase_factor"].IntValue[0]);
 496    TempIntVect.push_back(BrukerDataSet::BrukerHeaderMap[(std::string)  "NSLICES"].IntValue[0]);
 497    if (1<=BrukerDataSet::BrukerHeaderMap[ (std::string)  "ACQ_size" ].DimensionNumber ){
 498       TempIntVect.push_back(BrukerDataSet::BrukerHeaderMap[ (std::string)  "ACQ_size" ].IntValue[1]/BrukerDataSet::BrukerHeaderMap[(std::string)  "ACQ_phase_factor"].IntValue[0]);
 499    if (2<=BrukerDataSet::BrukerHeaderMap[ (std::string)  "ACQ_size" ].DimensionNumber )
 500    {
 501       for(i=2;i<=BrukerDataSet::BrukerHeaderMap[ (std::string)  "ACQ_size" ].DimensionNumber;i++)
 502       {
 503          TempIntVect.push_back(BrukerDataSet::BrukerHeaderMap[ (std::string)  "ACQ_size" ].IntValue[i]);
 504       }
 505    }
 506 }
 507 // Ici, boucles additionnelles si elles existent regroupees en une seule
 508 //temp=GetIntValueN(NIStr,1)/(GetIntValueN(NSLICESStr,1)*GetIntValueN(NECHOESStr,1));
 509    temp=BrukerDataSet::BrukerHeaderMap[ (std::string)  "NI" ].IntValue[0]/(BrukerDataSet::BrukerHeaderMap[ (std::string)  "NSLICES" ].IntValue[0]*BrukerDataSet::BrukerHeaderMap[ (std::string)  "ACQ_ns_list_size" ].IntValue[0]);
 510    if (1 < temp)
 511       TempIntVect.push_back(temp);
 512 // fin des boucles cachees
 513
 514    TempIntVect.push_back(BrukerDataSet::BrukerHeaderMap[ (std::string)  "NR" ].IntValue[0]);
 515
 516    LoopStructure=TempIntVect;
 517    return true;
 518 }
 519
 520
 521 /**
 522    @fn bool BrukerDataSet::SetLoopStructure ( )
 523  * @brief method to set the default Bruker loopstructure (not yet able to deal with EPI, SPIRAL or spectroscopic experiments
 524  * @return bool
 525    @todo  implement multicoil version
 526  */
 527 bool BrukerDataSet::SetLoopStructure ()
 528 {
 529    if (! SetInnerObjectLoopStructure()) return false;
 530    if (! SetOuterObjectLoopStructure()) return false;
 531    std::vector<int> Inner=GetInnerObjectLoopStructure();
 532    std::vector<int> Outer=GetOuterObjectLoopStructure();
 533    std::vector<int> TmpVect;
 534    TmpVect=Inner;
 535    TmpVect.insert(TmpVect.end(),Outer.begin(),Outer.end());
 536    LoopStructure=TmpVect;
 537    return true;
 538 }
 539
 540 std::vector< std :: vector < int > > BrukerDataSet::GetBrukerObjectsLineList() const
 541 {
 542    return BrukerObjectsLineList;
 543 }
 544
 545
 546 bool BrukerDataSet::SetBrukerObjectsLineList ()
 547 {
 548
 549    std::vector<int> Loop =GetLoopStructure();
 550    int NumberOfLines, i,j;
 551    NumberOfLines=1;
 552    i=1;
 553
 554    while (i<Loop.size())
 555    {
 556       NumberOfLines=NumberOfLines*Loop[i];
 557       i++;
 558    }
 559
 560    std::vector<int> TempVect  (Loop.size()-1,0);
 561    std::vector<int> k  (Loop.size()-1,0);
 562    std::vector<std::vector<int> > TempLineList (NumberOfLines,TempVect);
 563
 564    for (i=0;i<NumberOfLines;i++){
 565       for (j=1;j<=Loop.size()-1;j++) {
 566          if (k[j-1] >= Loop[j]) {
 567             k[j-1]=0;
 568             k[j]++;
 569          }
 570       }
 571       for (j=1;j<=Loop.size()-1;j++)
 572          TempLineList[i][j-1]=k[j-1];
 573       k[0]++;
 574    }
 575    BrukerObjectsLineList=TempLineList;
 576    return true;
 577 }
 578
 579
 580 std::vector< std::vector < int > > BrukerDataSet::GetBrukerImageList() const
 581 {
 582    return BrukerImageList;
 583 }
 584
 585
 586 bool BrukerDataSet::SetBrukerImageList ()
 587 {
 588    if (LoopStructure.size()==0)
 589       SetImageLoopStructure();
 590
 591    std::vector<int> Loop =GetImageLoopStructure();
 592    int NumberOfLines, i,j;
 593    NumberOfLines=1;
 594    i=1;
 595
 596    while (i<Loop.size())
 597    {
 598       NumberOfLines=NumberOfLines*Loop[i];
 599       i++;
 600    }
 601
 602    std::vector<int> TempVect (Loop.size()-1,0);
 603    std::vector<int> k (Loop.size()-1,0);
 604    std::vector<std::vector<int> > TempLineList (NumberOfLines,TempVect);
 605
 606    for (i=0;i<NumberOfLines;i++){
 607       for (j=1;j<=Loop.size()-1;j++) {
 608          if (k[j-1] >= Loop[j]) {
 609             k[j-1]=0;
 610             k[j]++;
 611          }
 612       }
 613       for (j=1;j<=Loop.size()-1;j++)
 614          TempLineList[i][j-1]=k[j-1];
 615       k[0]++;
 616    }
 617    BrukerImageList=TempLineList;
 618    return true;
 619 }
 620
 621
 622
 623 std::map<std::string, BrukerFieldData> BrukerDataSet::GetBrukerHeaderMap() const
 624 {
 625    return BrukerHeaderMap;
 626 }
 627
 628
 629
 630
 631 //std::map<std::string, BrukerFieldData> BrukerDataSet::GetBrukerHeaderMap() const
 632 //{
 633 //   return BrukerHeaderMap;
 634 //}
 635
 636
 637 bool BrukerDataSet::SetInnerObjectLoopStructure()
 638 {
 639 /*
 640  *
 641  *
 642  *      ACQ_size[1..M]                                  (Codage suivant les autres dimensions)
 643                 NSLICES                                 (Nombre de tranches)
 644                         ACQ_phase_factor                (Facteur turbo de la sequence)
 645                                 ACQ_ns_list_size        (Nombre d'echos)
 646                                         ACQ_size[0]     (Ligne acq reelle)
 647
 648 */
 649
 650    int  i, temp;
 651    std::vector<int> TempIntVect;
 652    TempIntVect.clear();
 653
 654
 655    if (! CheckExistKeyword("ACQ_size"))        return false;
 656    if (! CheckExistKeyword("ACQ_phase_factor"))return false;
 657    if (! CheckExistKeyword("ACQ_ns_list_size"))return false;
 658    if (! CheckExistKeyword("NSLICES"))         return false;
 659
 660
 661 //std::cout<< "BrukerDataSet::BrukerHeaderMap[ (std::string)  ACQ_size ].IntValue[0]" <<BrukerDataSet::BrukerHeaderMap[ (std::string)  "ACQ_size" ].IntValue[0] << std::endl;
 662    TempIntVect.push_back(BrukerDataSet::BrukerHeaderMap[ (std::string)  "ACQ_size" ].IntValue[0]);
 663 //std::cout<< "BrukerDataSet::BrukerHeaderMap[ (std::string)  ACQ_size ].IntValue[0]" <<BrukerDataSet::BrukerHeaderMap[ (std::string)  "ACQ_size" ].IntValue[0] << std::endl;
 664    TempIntVect.push_back(BrukerDataSet::BrukerHeaderMap[(std::string)  "ACQ_ns_list_size"].IntValue[0]);
 665 //std::cout<<"BrukerDataSet::BrukerHeaderMap[(std::string)  ACQ_ns_list_size].IntValue[0]" << BrukerDataSet::BrukerHeaderMap[(std::string)  "ACQ_ns_list_size"].IntValue[0] << std::endl;
 666    TempIntVect.push_back(BrukerDataSet::BrukerHeaderMap[(std::string)  "ACQ_phase_factor"].IntValue[0]);
 667 //std::cout<<"BrukerDataSet::BrukerHeaderMap[(std::string)  ACQ_phase_factor].IntValue[0]" <<  BrukerDataSet::BrukerHeaderMap[(std::string)  "ACQ_phase_factor"].IntValue[0]<< std::endl;
 668    TempIntVect.push_back(BrukerDataSet::BrukerHeaderMap[(std::string)  "NSLICES"].IntValue[0]);
 669 //std::cout << "BrukerDataSet::BrukerHeaderMap[(std::string)  NSLICES].IntValue[0]" << BrukerDataSet::BrukerHeaderMap[(std::string)  "NSLICES"].IntValue[0] << std::endl;
 670    if (1<=BrukerDataSet::BrukerHeaderMap[ (std::string)  "ACQ_size" ].DimensionNumber )
 671    {
 672       TempIntVect.push_back(BrukerDataSet::BrukerHeaderMap[ (std::string)  "ACQ_size" ].IntValue[1]/BrukerDataSet::BrukerHeaderMap[(std::string)  "ACQ_phase_factor"].IntValue[0]);
 673 //std::cout << "BrukerDataSet::BrukerHeaderMap[ (std::string)  ACQ_size ].IntValue[1]/BrukerDataSet::BrukerHeaderMap[(std::string)  ACQ_phase_factor].IntValue[0]" << BrukerDataSet::BrukerHeaderMap[ (std::string)  "ACQ_size"
 674 //].IntValue[1]/BrukerDataSet::BrukerHeaderMap[(std::string)  "ACQ_phase_factor"].IntValue[0] << std::endl;
 675       if (2<=BrukerDataSet::BrukerHeaderMap[ (std::string)  "ACQ_size" ].DimensionNumber )
 676       {
 677          for(i=2;i<=BrukerDataSet::BrukerHeaderMap[ (std::string)  "ACQ_size" ].DimensionNumber;i++)
 678          {
 679             TempIntVect.push_back(BrukerDataSet::BrukerHeaderMap[ (std::string)  "ACQ_size" ].IntValue[i]);
 680          }
 681       }
 682    }
 683
 684    InnerObjectLoopStructure=TempIntVect;
 685    return true;
 686 }
 687
 688
 689 std::vector< int > BrukerDataSet::GetInnerObjectLoopStructure() const
 690 {
 691    return InnerObjectLoopStructure;
 692 }
 693
 694 std::vector< int > BrukerDataSet::GetOuterObjectLoopStructure() const
 695 {
 696    return OuterObjectLoopStructure;
 697 }
 698
 699
 700 bool BrukerDataSet::SetOuterObjectLoopStructure ()
 701 {
 702    OuterObjectLoopStructure.clear();
 703    /*
 704     NR      (Nbre de repetitions)
 705     NILoop  (Boucle eventuelle extra (Diffusion par exemple) si NI<>(NSLICES x NECHOES) cette boucle est a� NI/(NSLICES x NECHOES)
 706        (Attention NILoop peut masquer plusieurs boucles imbriquees !!!!!)
 707   */
 708    int  temp;
 709    std::vector<int> TempIntVect;
 710    TempIntVect.clear();
 711    if (! CheckExistKeyword("NR")) return false;
 712    if (! CheckExistKeyword("NI"))  return false;
 713 // Ici, boucles additionnelles si elles existent regroupees en une seule
 714 //temp=GetIntValueN(NIStr,1)/(GetIntValueN(NSLICESStr,1)*GetIntValueN(NECHOESStr,1));
 715    temp=BrukerDataSet::BrukerHeaderMap[ (std::string)  "NI" ].IntValue[0]/(BrukerDataSet::BrukerHeaderMap[ (std::string)  "NSLICES" ].IntValue[0]*BrukerDataSet::BrukerHeaderMap[ (std::string)  "ACQ_ns_list_size" ].IntValue[0]);
 716    if (1 < temp)
 717       TempIntVect.push_back(temp);
 718 // fin des boucles cachees
 719    TempIntVect.push_back(BrukerDataSet::BrukerHeaderMap[ (std::string)  "NR" ].IntValue[0]);
 720    OuterObjectLoopStructure=TempIntVect;
 721    return true;
 722 }
 723
 724
 725 std::vector< int > BrukerDataSet::GetImageLoopStructure() const
 726 {
 727    return ImageLoopStructure;
 728 }
 729
 730
 731 bool BrukerDataSet::SetImageLoopStructure ( )
 732 {
 733    ImageLoopStructure.clear();
 734    std::vector<int> TempIntVect1=GetInnerObjectLoopStructure();
 735    std::vector<int> TempIntVect2=GetOuterObjectLoopStructure();
 736    std::vector<int> TempIntVect3(TempIntVect1.size(),1);
 737    std::vector<int> TempIntVect4;
 738    TempIntVect3[1]=TempIntVect1[1];
 739    TempIntVect3[3]=TempIntVect1[3];
 740    TempIntVect4=TempIntVect3;
 741    TempIntVect4.insert(TempIntVect4.end(),TempIntVect2.begin(),TempIntVect2.end());
 742    ImageLoopStructure = TempIntVect4;
 743    return true;
 744 }
 745