Xmipp  v3.23.11-Nereus
Classes | Functions
Collaboration diagram for DM3 File format:

Classes

struct  DM3head
 
struct  DM3dataHead
 

Functions

DataType datatypeDM3 (int nType)
 
void FREADTagValueDM3 (double *fieldValue, int numberType, int n, FILE *fimg, bool swap)
 
double readTagDM3 (FILE *fimg, DM3head *header, int parentId, int &nodeId, bool isLE, bool swap)
 
int parentDM3 (MetaData &MD, int nodeId, int depth=1)
 
size_t gotoTagDM3 (MetaData &MD, int &nodeId, const std::string &tagsList)
 
void printDM3node (const MetaData &MD, size_t id)
 
void printDM3 (const MetaData &MD)
 
int readDM3 (size_t img_select, bool isStack=false)
 
int writeDM3 (size_t img_select, bool isStack=false, int mode=WRITE_OVERWRITE)
 
int ImageBase::readDM3 (size_t img_select, bool isStack=false)
 
int ImageBase::writeDM3 (size_t img_select, bool isStack=false, int mode=WRITE_OVERWRITE)
 

Detailed Description

Function Documentation

◆ datatypeDM3()

DataType datatypeDM3 ( int  nType)

DM3 Determine DM3 datatype

Definition at line 70 of file rwDM3.cpp.

71 {
72  DataType datatype;
73 
74  switch(nType)
75  {
76  case 2: // (02h = 2 i2* signed (short)
77  datatype = DT_Short;
78  break;
79  case 3: // 03h = 3 i4* signed (long)
80  datatype = DT_Int;
81  break;
82  case 4: // 04h = 4 i2* unsigned (ushort) or unicode string
83  datatype = DT_UShort;
84  break;
85  case 5: // 05h = 5 i4* unsigned (ulong)
86  datatype = DT_UInt;
87  break;
88  case 6: // 06h = 6 f4* (float)
89  datatype = DT_Float;
90  break;
91  case 7: // 07h = 7 f8* (double)
92  datatype = DT_Double;
93  break;
94  case 8: // 08h = 8 i1 (boolean)
95  datatype = DT_Bool;
96  break;
97  case 9: // 0ah = 10 i1
98  datatype = DT_SChar;
99  break;
100  case 10: // 0ah = 10 i1
101  datatype = DT_SChar;
102  break;
103  default:
104  datatype = DT_Unknown;
105  break;
106  }
107  return datatype;
108 }
DataType

◆ FREADTagValueDM3()

void FREADTagValueDM3 ( double *  fieldValue,
int  numberType,
int  n,
FILE *  fimg,
bool  swap 
)

DM3 Low level reader

Definition at line 113 of file rwDM3.cpp.

114 {
115  DataType datatype = datatypeDM3(numberType);
116  size_t datatypesize=gettypesize(datatype);
117 
118  xmippFREAD(fieldValue, datatypesize, n, fimg, swap);
119 
120  switch(numberType)
121  {
122  case 2: // (02h = 2 i2* signed (short)
123  {
124  short* sValue = (short*) fieldValue;
125  *fieldValue = (double) *sValue;
126  break;
127  }
128  case 3: // 03h = 3 i4* signed (long)
129  {
130  int* iValue = (int*) fieldValue;
131  *fieldValue = (double) *iValue;
132  break;
133  }
134  case 4: // 04h = 4 i2* unsigned (ushort) or unicode string
135  {
136  unsigned short* usValue = (unsigned short*) fieldValue;
137  *fieldValue = (double) *usValue;
138  break;
139  }
140  case 5: // 05h = 5 i4* unsigned (ulong)
141  {
142  unsigned int* uiValue = (unsigned int*) fieldValue;
143  *fieldValue = (double) *uiValue;
144  break;
145  }
146  case 6: // 06h = 6 f4* (float)
147  {
148  float* fValue = (float*) fieldValue;
149  *fieldValue = (double) *fValue;
150  break;
151  }
152  case 7: // 07h = 7 f8* (double)
153  {
154  // double* caca = (double*) fieldValue;
155  break;
156  }
157  case 8: // 08h = 8 i1 (boolean)
158  {
159  bool* bValue = (bool*) fieldValue;
160  *fieldValue = (double) *bValue;
161  break;
162  }
163  case 9: // 0ah = 10 i1
164  case 10: // 0ah = 10 i1
165  {
166  char* cValue = (char*) fieldValue;
167  *fieldValue = (double) *cValue;
168  break;
169  }
170  default:
171  {
172  break;
173  }
174  }
175 }
DataType
size_t xmippFREAD(void *dest, size_t size, size_t nitems, FILE *&fp, bool reverse)
DataType datatypeDM3(int nType)
Definition: rwDM3.cpp:70
int * n
size_t gettypesize(DataType type)
Returns memory size of datatype.

◆ gotoTagDM3()

size_t gotoTagDM3 ( MetaData MD,
int &  nodeId,
const std::string &  tagsList 
)

DM3 Go to tag

Definition at line 366 of file rwDM3.cpp.

367 {
368  std::string tag;
369  std::vector<std::string> vTags;
370  splitString(tagsList,",",vTags, false);
371  size_t id=0;
372 
373  MDValueEQ queryParentId(MDL_DM3_PARENTID,-1), queryTagname(MDL_DM3_TAGNAME,tag);
374  MDMultiQuery queries;
375 
376  queries.addAndQuery(queryParentId);
377  queries.addAndQuery(queryTagname);
378 
379  for (size_t n = 0; n < vTags.size(); n++)
380  {
381  tag = vTags[n];
382 
383  queryParentId.setValue(nodeId);
384  queryTagname.setValue(tag);
385  id = MD.firstObject(queries);
386  if (id != BAD_OBJID)
387  {
388  MD.getValue(MDL_DM3_NODEID, nodeId, id);
389  }
390  }
391  return id;
392 }
void addAndQuery(MDQuery &query)
virtual size_t firstObject(const MDQuery &) const =0
virtual bool getValue(MDObject &mdValueOut, size_t id) const =0
int splitString(const String &input, const String &delimiter, StringVector &results, bool includeEmpties)
int * n
#define BAD_OBJID
Definition: metadata_base.h:55

◆ parentDM3()

int parentDM3 ( MetaData MD,
int  nodeId,
int  depth = 1 
)

DM3 Get DM3 parent

Definition at line 351 of file rwDM3.cpp.

352 {
353  for (int n = 0; n < depth; n++)
354  {
356 
357  if (nodeId == 0)
358  break;
359  }
360  return nodeId;
361 }
virtual size_t firstObject(const MDQuery &) const =0
virtual bool getValue(MDObject &mdValueOut, size_t id) const =0
int * n

◆ printDM3()

void printDM3 ( const MetaData MD)

DM3 Print DM3 header

Definition at line 426 of file rwDM3.cpp.

427 {
428  std::vector<size_t> vObjs;
429  space = 0;
430  MD.findObjects(vObjs,MDValueEQ(MDL_DM3_PARENTID, 0));
431 
432  for (size_t i = 0; i < vObjs.size(); i++)
433  printDM3node(MD, vObjs[i]);
434 }
#define i
void printDM3node(const MetaData &MD, size_t id)
Definition: rwDM3.cpp:398
virtual void findObjects(std::vector< size_t > &objectsOut, const MDQuery &query) const =0
int space
Definition: rwDM3.cpp:394

◆ printDM3node()

void printDM3node ( const MetaData MD,
size_t  id 
)

DM3 Print DM3 node

Definition at line 398 of file rwDM3.cpp.

399 {
400  std::string tag;
401  MD.getValue(MDL_DM3_TAGNAME, tag, id);
402 
403  int nodeId;
404  MD.getValue(MDL_DM3_NODEID, nodeId, id);
405 
406  for (int i = 0; i < space; i++)
407  std::cout << " ";
408 
409  std::cout << tag << std::endl;
410 
411  std::vector<size_t> vObjs;
412  MD.findObjects(vObjs, MDValueEQ(MDL_DM3_PARENTID, nodeId));
413 
414  space += 3;
415 
416  for (size_t i = 0; i < vObjs.size(); i++)
417  printDM3node(MD, vObjs[i]);
418 
419  space -= 3;
420 
421 }
virtual bool getValue(MDObject &mdValueOut, size_t id) const =0
#define i
void printDM3node(const MetaData &MD, size_t id)
Definition: rwDM3.cpp:398
virtual void findObjects(std::vector< size_t > &objectsOut, const MDQuery &query) const =0
int space
Definition: rwDM3.cpp:394

◆ readDM3() [1/2]

int readDM3 ( size_t  img_select,
bool  isStack = false 
)

DM3 Reader

◆ readDM3() [2/2]

int ImageBase::readDM3 ( size_t  select_img,
bool  isStack = false 
)
protected

DM3 Reader

Definition at line 445 of file rwDM3.cpp.

446 {
447 #undef DEBUG
448  //#define DEBUG
449 #ifdef DEBUG
450  printf("DEBUG readDM3: Reading DM3 file\n");
451 #endif
452 
453  DM3head * header = new DM3head;
454  int dummy;
455 
456  // Check Machine endianness
457  bool isLE = IsLittleEndian();
458 
459  xmippFREAD(&header->fileVersion, sizeof(int), 1, fimg, isLE);
460  xmippFREAD(&dummy, sizeof(int), 1, fimg, isLE);
461  xmippFREAD(&header->byteOrder, sizeof(int), 1, fimg, isLE);
462 
463  // Set Endianess
464  swap = (isLE^header->byteOrder);
465 
466  if ( header->fileVersion!=3 )
467  REPORT_ERROR(ERR_IO_NOREAD, "readDM3: Input file is not Digital Micrograph 3 format.");
468 
469  xmippFREAD(&header->sorted, sizeof(char), 1, fimg, false);
470  xmippFREAD(&header->open, sizeof(char), 1, fimg, false);
471  xmippFREAD(&header->nTags, sizeof(int), 1, fimg, isLE);
472 
473  header->tags.addLabel(MDL_DM3_NODEID);
474  header->tags.addLabel(MDL_DM3_PARENTID);
475  header->tags.addLabel(MDL_DM3_IDTAG);
476  header->tags.addLabel(MDL_DM3_TAGNAME);
477  header->tags.addLabel(MDL_DM3_TAGCLASS);
478  header->tags.addLabel(MDL_DM3_SIZE);
480  header->tags.addLabel(MDL_DM3_VALUE);
481 
482  int nodeID = 0, parentID = 0;
483 
484  for (int n=1;n<=header->nTags;n++)
485  readTagDM3(fimg, header, parentID, nodeID, isLE, swap);
486 
487  //#define DEBUG
488 #ifdef DEBUG
489 
490  header->tags.write("images.txt");
491  printDM3(header->tags);
492 #endif
493 
494 
495  //std::vector<size_t> vIm;
496  //header->tags.findObjects(vIm, );
497 
498  header->nIm = 0;
499  std::vector<DM3dataHead> dataHeaders;
500  DM3dataHead dhRef;
501 
502  std::vector<double> vValue;
503  int iValue;
504  size_t id;
505  //Initialize query for later use
506  MDValueEQ queryNodeId(MDL_DM3_NODEID, -1);
507 
508  std::vector<size_t> objIdsDataType;
509  header->tags.findObjects(objIdsDataType, MDValueEQ(MDL_DM3_TAGNAME,(String)"DataType"));
510 
511  for (size_t objId : objIdsDataType)
512  // Read all the image headers
513  //for (int n = 0; n < vIm.size(); n++)
514  {
515  //header->tags.goToObject(vIm[n]);
516  header->tags.getValue(MDL_DM3_VALUE, vValue, objId);
517 
518  if (vValue[0] != 23) //avoid thumb images
519  {
520  dataHeaders.push_back(dhRef);
521 
522  parentID = parentDM3(header->tags, objId, 2);
523 
524  nodeID = parentID;
525  id = gotoTagDM3(header->tags, nodeID, "ImageData,Data");
526  header->tags.getValue(MDL_DM3_NUMBER_TYPE, iValue, id);
527  dataHeaders[header->nIm].dataType = (short int) iValue;
528 
529  header->tags.getValue(MDL_DM3_VALUE, vValue, id);
530  dataHeaders[header->nIm].headerSize = (size_t) vValue[0];
531 
532  nodeID = parentID;
533  gotoTagDM3(header->tags, nodeID, "ImageData,Dimensions");
534  nodeID++;
535  queryNodeId.setValue(nodeID);
536  id = header->tags.firstObject(queryNodeId);
537  header->tags.getValue(MDL_DM3_VALUE, vValue, id);
538  dataHeaders[header->nIm].imageWidth = (int) vValue[0];
539 
540  nodeID++;
541  queryNodeId.setValue(nodeID);
542  id = header->tags.firstObject(queryNodeId);
543  header->tags.getValue(MDL_DM3_VALUE, vValue, id);
544  dataHeaders[header->nIm].imageHeight = (int) vValue[0];
545 
546  nodeID++;
547  queryNodeId.setValue(nodeID);
548  id = header->tags.firstObject(queryNodeId);
549  header->tags.getValue(MDL_DM3_VALUE, vValue, id);
550  dataHeaders[header->nIm].dataTypeSize = (short int) vValue[0];
551 
552  nodeID = parentID;
553  id = gotoTagDM3(header->tags, nodeID, "ImageTags,Acquisition,Frame,CCD,Pixel Size (um)");
554  // header->tags.nextObject();
555  if (id != BAD_OBJID)
556  {
557  header->tags.getValue(MDL_DM3_VALUE, vValue, id);
558  dataHeaders[header->nIm].pixelHeight = vValue[0]*1e4;
559  dataHeaders[header->nIm].pixelWidth = vValue[1]*1e4;
560  }
561 
562  //TODO: Do I have to include FLIP?!?!? which? vertical or horizontal?
563  header->nIm++;
564  }
565 
566  }
567 
568  if (dataHeaders.size() == 0)
569  REPORT_ERROR(ERR_IMG_NOREAD,formatString("readDM3: Image information not found in file %s",filename.c_str()));
570 
571  int _xDim,_yDim;
572  size_t _nDim;
573  _xDim = dataHeaders[0].imageWidth;
574  _yDim = dataHeaders[0].imageHeight;
575  _nDim = header->nIm;
576 
577  // Map the parameters
578  if (select_img > _nDim)
579  REPORT_ERROR(ERR_INDEX_OUTOFBOUNDS, formatString("readDM3: Image number %lu exceeds stack size %lu", select_img, _nDim));
580  else if (select_img == ALL_IMAGES)
581  {
582  // Check images dimensions. Need to be the same
583  for (size_t i = 1; i < _nDim ; i++)
584  {
585  if (dataHeaders[0].imageHeight != dataHeaders[i].imageHeight || \
586  dataHeaders[0].imageWidth != dataHeaders[i].imageWidth || \
587  dataHeaders[0].dataType != dataHeaders[i].dataType)
588  REPORT_ERROR(ERR_IMG_NOREAD, "readDM3: images in DM3 file with different \
589  dimensions and data types are not currently supported. Try to read them individually.");
590  }
591  //FIXME: Code is not totally implemented to load automatically multiple images if they have same size.
592  if (_nDim > 1)
593  REPORT_ERROR(ERR_IO_NOREAD, "readDM3: Reading multiple \
594  images at once in DM3 file are not currently supported. Try to read them individually.");
595  }
596  else
597  _nDim = 1;
598 
599  setDimensions(_xDim, _yDim, 1, _nDim);
600 
601  size_t imgStart = IMG_INDEX(select_img);
602  size_t imgEnd = (select_img != ALL_IMAGES) ? imgStart + 1 : _nDim;
603 
604  DataType datatype = datatypeDM3(dataHeaders[0].dataType);
605 
606  MDMainHeader.setValue(MDL_SAMPLINGRATE_X,(double)dataHeaders[0].pixelWidth);
607  MDMainHeader.setValue(MDL_SAMPLINGRATE_Y,(double)dataHeaders[0].pixelHeight);
608  MDMainHeader.setValue(MDL_DATATYPE,(int)datatype);
609 
610  if (dataMode == HEADER) // Stop reading if not necessary
611  {
612  delete header;
613  return 0;
614  }
615 
616  MD.clear();
617  for (size_t i = 0; i < imgEnd-imgStart; i++)
618  MD.push_back(std::unique_ptr<MDRowVec>(new MDRowVec(MDL::emptyHeaderVec())));
619  offset = dataHeaders[imgStart].headerSize;
620  delete header;
621 
622  if( dataMode < DATA )
623  return 0;
624 
625 #undef DEBUG
626 #ifdef DEBUG
627 
628  MDMainHeader.write(std::cerr);
629  MD.write(std::cerr);
630 #endif
631 
632  size_t pad = 0;
633  readData(fimg, select_img, datatype, pad);
634 
635  return(0);
636 }
Index out of bounds.
Definition: xmipp_error.h:132
sampling rate in A/pixel (double)
sampling rate in A/pixel (double)
DataMode dataMode
bool IsLittleEndian(void)
#define REPORT_ERROR(nerr, ErrormMsg)
Definition: xmipp_error.h:211
virtual void readData(FILE *fimg, size_t select_img, DataType datatype, size_t pad)=0
void setValue(const MDObject &object) override
std::vector< std::unique_ptr< MDRow > > MD
size_t firstObject(const MDQuery &) const override
if read from file original image datatype, this is an struct defined in image
void write(const FileName &outFile, WriteModeMetaData mode=MD_OVERWRITE) const
Cannot read image from file.
Definition: xmipp_error.h:128
#define i
char sorted
Definition: rwDM3.cpp:41
int byteOrder
Definition: rwDM3.cpp:40
void findObjects(std::vector< size_t > &objectsOut, const MDQuery &query) const override
virtual void setDimensions(int Xdim, int Ydim, int Zdim, size_t Ndim)=0
size_t gotoTagDM3(MetaData &MD, int &nodeId, const std::string &tagsList)
Definition: rwDM3.cpp:366
char open
Definition: rwDM3.cpp:42
double readTagDM3(FILE *fimg, DM3head *header, int parentId, int &nodeId, bool isLE, bool swap)
Definition: rwDM3.cpp:180
Couldn&#39;t read from file.
Definition: xmipp_error.h:139
static MDRowVec emptyHeaderVec()
DataType
double dummy
size_t xmippFREAD(void *dest, size_t size, size_t nitems, FILE *&fp, bool reverse)
bool getValue(MDObject &mdValueOut, size_t id) const override
bool addLabel(const MDLabel label, int pos=-1) override
MDRowVec MDMainHeader
int parentDM3(MetaData &MD, int nodeId, int depth=1)
Definition: rwDM3.cpp:351
DataType datatype() const
std::string String
Definition: xmipp_strings.h:34
int fileVersion
Definition: rwDM3.cpp:38
#define ALL_IMAGES
String formatString(const char *format,...)
#define IMG_INDEX(select_img)
DataType datatypeDM3(int nType)
Definition: rwDM3.cpp:70
FileName filename
MetaDataVec tags
Definition: rwDM3.cpp:44
int nTags
Definition: rwDM3.cpp:43
void printDM3(const MetaData &MD)
Definition: rwDM3.cpp:426
int * n
#define BAD_OBJID
Definition: metadata_base.h:55
int nIm
Definition: rwDM3.cpp:45

◆ readTagDM3()

double readTagDM3 ( FILE *  fimg,
DM3head header,
int  parentId,
int &  nodeId,
bool  isLE,
bool  swap 
)

DM3 Tag reader

Definition at line 180 of file rwDM3.cpp.

181 {
182  /* Header Tag ============================================================== */
183  unsigned char cdTag;
184  unsigned short int ltName;
185 
186  xmippFREAD(&cdTag,sizeof (unsigned char),1,fimg,false); // Identification tag: 20 = tag dir, 21 = tag
187  xmippFREAD(&ltName,sizeof(unsigned short int), 1,fimg,isLE); // Length of the tag name
188  int idTag = int(cdTag);
189 
190  std::string stagName;
191 
192  char * tagName = new char[ltName+1];
193  xmippFREAD(tagName,1,ltName,fimg,false); // Tag name
194  tagName[ltName] = '\0';
195  stagName = tagName;
196  delete [] tagName;
197 
198  size_t id = header->tags.addObject();
199 
200  nodeId++;
201  header->tags.setValue(MDL_DM3_NODEID, nodeId, id);
202  header->tags.setValue(MDL_DM3_PARENTID, parentId, id);
203  header->tags.setValue(MDL_DM3_IDTAG, idTag, id);
204  header->tags.setValue(MDL_DM3_TAGNAME, stagName, id);
205 
206  /* Reading tags ===================================================================*/
207  if (idTag == 20) // Tag directory
208  {
209  unsigned char dummy;
210  int nTags;
211  xmippFREAD(&dummy,sizeof(unsigned char),1,fimg,false); // 1 = sorted (normally = 1)
212  xmippFREAD(&dummy,sizeof(unsigned char),1,fimg,false); // 0 = closed, 1 = open (normally = 0)
213  xmippFREAD(&nTags,sizeof(int),1,fimg,isLE); // number of tags in tag directory
214 
215 
216  header->tags.setValue(MDL_DM3_TAGCLASS,(std::string) "Dir", id);
217  header->tags.setValue(MDL_DM3_SIZE, nTags, id);
218 
219  parentId = nodeId;
220  for (int n=1;n<=nTags;n++) // Rest of directories
221  {
222  readTagDM3(fimg, header, parentId, nodeId, isLE, swap);
223  }
224  return 0;
225  }
226  else if (idTag == 21) // Tag
227  {
228  unsigned int nnum;
229  char buf[4]; // to read %%%% symbols
230 
231  xmippFREAD(&buf,1,4,fimg,false); // To read %%%% symbols
232  xmippFREAD(&nnum,sizeof(unsigned int),1,fimg,isLE); // Size of info array
233 
234  int * info;
235  info = new int[nnum];
236  xmippFREAD(info,sizeof(unsigned int),nnum,fimg,isLE); // Reading of Info
237 
238  /* Tag classification =======================================*/
239 
240  if (nnum == 1) // Single entry tag
241  {
242  header->tags.setValue(MDL_DM3_TAGCLASS,(std::string) "Single", id);
243 
244  double tagValue = 0;
245 
246  FREADTagValueDM3(&tagValue,info[0],1,fimg,swap);
247 
248  std::vector<double> vtagValue(1);
249  vtagValue.assign(1,tagValue);
250 
251  header->tags.setValue(MDL_DM3_NUMBER_TYPE, info[0], id);
252  header->tags.setValue(MDL_DM3_VALUE, vtagValue, id);
253  delete []info;
254  return tagValue;
255  }
256  else if(nnum == 3 && info[0]==20) // Tag array
257  {
258  /*nnum = 3
259  info(0) = 20
260  info(1) = number type for all values
261  info(2) = info(nnum) = size of array*/
262 
263  header->tags.setValue(MDL_DM3_TAGCLASS,(std::string) "Array", id);
264 
265  header->tags.setValue(MDL_DM3_NUMBER_TYPE, info[1], id);
266  header->tags.setValue(MDL_DM3_SIZE, info[nnum-1], id);
267  std::vector<double> vtagValue(1);
268  vtagValue.assign(1,(double) ftell(fimg));
269 
270  header->tags.setValue(MDL_DM3_VALUE, vtagValue, id);
271 
272  // Jump the array values
273  int k;
274  if(info[1] == 2 || info[1] == 4)
275  k = 2;
276  else if(info[1] == 3 || info[1] == 5 || info[1] == 6)
277  k = 4;
278  else if(info[1] == 10 )
279  k = 1;
280  else
281  REPORT_ERROR(ERR_ARG_INCORRECT,formatString("unsupported value info[1]=%d, read at %d",info[1],ftell(fimg)));
282 
283  fseek( fimg, ftell(fimg)+(info[nnum-1])*k , SEEK_SET );
284  delete []info;
285  return 0;
286  }
287  else if (info[0]==20 && info[1] == 15) // Tag Group array
288  {
289  /*nnum = size of array
290  info(0) = 20 (array)
291  info(1) = 15 (group)
292  info(2) = 0 (always 0)
293  info(3) = number of values in group
294  info(2*i+3) = number type for value i
295  info(nnum) = size of info array*/
296 
297  header->tags.setValue(MDL_DM3_TAGCLASS, (std::string) "GroupArray", id);
298  header->tags.setValue(MDL_DM3_SIZE, info[3], id);
299  int nBytes=0, k;
300  double fieldValue;
301  for (int n=1;n<=info[3];n++)
302  {
303  fieldValue=0;
304  FREADTagValueDM3(&fieldValue,info[3+2*n],1,fimg,swap);
305 
306  if(info[3+2*n] == 2 || info[3+2*n] == 4)
307  k = 2;
308  else if(info[3+2*n] == 3 || info[3+2*n] == 5)
309  k = 4;
310  else if(info[3+2*n] == 10 )
311  k = 1;
312  nBytes+=k;
313  }
314 
315  // Jump the array values
316  fseek( fimg, ftell(fimg)+(info[nnum-1]-1)*nBytes , SEEK_SET );
317  delete []info;
318  return 0;
319  }
320  else if (info[0] == 15) // Tag Group (struct)
321  {
322  /* info[1] = length group name (always =0)
323  info[2] = number of entries in group */
324  /*nnum = size of info array
325  info(1) = 0fh
326  info(3) = number of values in group
327  info(2*i+3) = number type for value i
328  Other info entries are always zero*/
329 
330  header->tags.setValue(MDL_DM3_TAGCLASS, (std::string) "Group", id);
331  header->tags.setValue(MDL_DM3_SIZE, info[2], id);
332  std::vector<double> vtagValue(info[2]);
333  for (int n=1;n<=info[2];n++)
334  {
335  double fieldValue=0;
336  FREADTagValueDM3(&fieldValue,info[2+2*n],1,fimg,swap);
337  vtagValue.assign(n,fieldValue);
338  }
339  header->tags.setValue(MDL_DM3_VALUE, vtagValue, id);
340  delete []info;
341  return 0;
342  }
343  delete []info;
344  }
345  return 0;
346 }
#define REPORT_ERROR(nerr, ErrormMsg)
Definition: xmipp_error.h:211
void FREADTagValueDM3(double *fieldValue, int numberType, int n, FILE *fimg, bool swap)
Definition: rwDM3.cpp:113
ql0001_ & k(htemp+1),(cvec+1),(atemp+1),(bj+1),(bl+1),(bu+1),(x+1),(clamda+1), &iout, infoqp, &zero,(w+1), &lenw,(iw+1), &leniw, &glob_grd.epsmac
bool setValue(const MDObject &mdValueIn, size_t id)
size_t addObject() override
Incorrect argument received.
Definition: xmipp_error.h:113
double readTagDM3(FILE *fimg, DM3head *header, int parentId, int &nodeId, bool isLE, bool swap)
Definition: rwDM3.cpp:180
double dummy
size_t xmippFREAD(void *dest, size_t size, size_t nitems, FILE *&fp, bool reverse)
String formatString(const char *format,...)
MetaDataVec tags
Definition: rwDM3.cpp:44
int * n

◆ writeDM3() [1/2]

int writeDM3 ( size_t  img_select,
bool  isStack = false,
int  mode = WRITE_OVERWRITE 
)

DM3 Writer

◆ writeDM3() [2/2]

int ImageBase::writeDM3 ( size_t  img_select,
bool  isStack = false,
int  mode = WRITE_OVERWRITE 
)
protected

DM3 Writer

Definition at line 437 of file rwDM3.cpp.

438 {
439  REPORT_ERROR(ERR_IO_NOWRITE, "ERROR: writeDM3 is not implemented.");
440 }
#define REPORT_ERROR(nerr, ErrormMsg)
Definition: xmipp_error.h:211
Couldn&#39;t write to file.
Definition: xmipp_error.h:140