Main Page | Modules | Namespace List | Class Hierarchy | Alphabetical List | Class List | Directories | File List | Namespace Members | Class Members | File Members

EMAN::SerIO Class Reference

SER (Series File Format) is a file format created by Dr. More...

#include <serio.h>

Inheritance diagram for EMAN::SerIO:

Inheritance graph
[legend]
Collaboration diagram for EMAN::SerIO:

Collaboration graph
[legend]
List of all members.

Public Member Functions

 SerIO (const string &filename, IOMode rw_mode=READ_ONLY)
 ~SerIO ()
int get_nimg ()
 Return the number of images in this image file.

Static Public Member Functions

bool is_valid (const void *first_block)

Public Attributes

 DEFINE_IMAGEIO_FUNC

Private Types

enum  SerImgMode { oneD = 0x4120, twoD = 0x4122 }
enum  SerTagType { timeOnly = 0x4152, posTime = 0x4122 }
enum  SerDataMode {
  SER_UCHAR = 1, SER_USHORT, SER_UINT, SER_CHAR,
  SER_SHORT, SER_INT, SER_FLOAT, SER_DOUBLE,
  SER_COMPLEX8, SER_COMPLEX16, UNKNOWN
}

Private Member Functions

void read_dim_arr (Dict &dict, int idx)
 helper function to read attributes in dimension array
void read_data_element (Dict &dict)
 helper function to read header attributes in data element
void read_data_tag (Dict &dict)
 helper function to read header attributes in data tag

Private Attributes

string filename
IOMode rw_mode
FILE * serfile
bool initialized
bool is_new_file
SerHeader serh
int * data_offset_array
int * tag_offset_array
int nimg
int nx
int ny
int nz
int datatypeid
int datamode

Detailed Description

SER (Series File Format) is a file format created by Dr.

Chris Boothroyd. The file format is used by TIA (Tecnai imaging and analysis), which is the program used on FEI Tecnai and Titan microscopes for acquiring and displaying scanned images and spectra.

Each .ser file stores a number of 1D or 2D images. We do not support complex SER image for now.

http://www.microscopy.cen.dtu.dk/~cbb/info/TIAformat/index.html

Definition at line 53 of file serio.h.


Member Enumeration Documentation

enum EMAN::SerIO::SerDataMode [private]
 

Enumeration values:
SER_UCHAR 
SER_USHORT 
SER_UINT 
SER_CHAR 
SER_SHORT 
SER_INT 
SER_FLOAT 
SER_DOUBLE 
SER_COMPLEX8 
SER_COMPLEX16 
UNKNOWN 

Definition at line 74 of file serio.h.

00074                                  {
00075                         SER_UCHAR = 1,
00076                         SER_USHORT,
00077                         SER_UINT,
00078                         SER_CHAR,
00079                         SER_SHORT,
00080                         SER_INT,
00081                         SER_FLOAT,
00082                         SER_DOUBLE,
00083                         SER_COMPLEX8,
00084                         SER_COMPLEX16,
00085                         UNKNOWN
00086                 };

enum EMAN::SerIO::SerImgMode [private]
 

Enumeration values:
oneD 
twoD 

Definition at line 64 of file serio.h.

00064                                 {
00065                         oneD = 0x4120,
00066                         twoD = 0x4122
00067                 };

enum EMAN::SerIO::SerTagType [private]
 

Enumeration values:
timeOnly 
posTime 

Definition at line 69 of file serio.h.

00069                                 {
00070                         timeOnly = 0x4152,
00071                         posTime  = 0x4122
00072                 };


Constructor & Destructor Documentation

SerIO::SerIO const string &  filename,
IOMode  rw_mode = READ_ONLY
[explicit]
 

Definition at line 49 of file serio.cpp.

References nx, and ny.

00049                                            :
00050                 filename(file), rw_mode(rw), serfile(0), initialized(false),
00051                 is_new_file(false), data_offset_array(0),tag_offset_array(0),
00052                 nimg(0), nx(0), ny(0), nz(0), datatypeid(0), datamode(0)
00053 {
00054 }

SerIO::~SerIO  ) 
 

Definition at line 56 of file serio.cpp.

References data_offset_array, serfile, and tag_offset_array.

00057 {
00058         if (serfile) {
00059                 fclose(serfile);
00060                 serfile = 0;
00061         }
00062 
00063         if (data_offset_array) {
00064                 delete [] data_offset_array;
00065                 data_offset_array = 0;
00066         }
00067 
00068         if (tag_offset_array) {
00069                 delete [] tag_offset_array;
00070                 tag_offset_array = 0;
00071         }
00072 }


Member Function Documentation

int SerIO::get_nimg  )  [virtual]
 

Return the number of images in this image file.

Reimplemented from EMAN::ImageIO.

Definition at line 347 of file serio.cpp.

References filename, ImageReadException, EMAN::ImageIO::init(), portable_fseek(), serfile, and ValidNumberElementsOffset.

00347                     {
00348         init();
00349 
00350         portable_fseek(serfile, ValidNumberElementsOffset, SEEK_SET);
00351         int nimg;
00352         if (fread(&nimg, sizeof(int), 1, serfile) != 1) {
00353                 throw ImageReadException(filename, "SER header");
00354         }
00355 
00356         return nimg;
00357 }

bool SerIO::is_valid const void *  first_block  )  [static]
 

Definition at line 98 of file serio.cpp.

References data.

Referenced by EMAN::EMUtil::fast_get_image_type(), and EMAN::EMUtil::get_image_type().

00099 {
00100         ENTERFUNC;
00101 
00102         if (!first_block) {
00103                 return false;
00104         }
00105 
00106         const short *data = static_cast < const short *>(first_block);
00107         short ByteOrder = data[0];
00108         short SeriesID = data[1];
00109 
00110         if(ByteOrder != 0x4949 || SeriesID != 0x0197) {
00111                 return false;
00112         }
00113 
00114         EXITFUNC;
00115         return true;
00116 }

void SerIO::read_data_element Dict dict  )  [private]
 

helper function to read header attributes in data element

Definition at line 420 of file serio.cpp.

References datamode, datatypeid, filename, ImageReadException, nx, ny, and serfile.

00421 {
00422         if(this->datatypeid == oneD) {  //1D image
00423                 double hitem4[2];
00424                 if (fread(hitem4, sizeof(double), 2, serfile) != 2) {
00425                         throw ImageReadException(filename, "SER header");
00426                 }
00427                 dict["SER.CalibrationOffset"]   = hitem4[0];
00428                 dict["SER.CalibrationDelta"]    = hitem4[1];
00429 
00430                 int cali;
00431                 if (fread(&cali, sizeof(int), 1, serfile) != 1) {
00432                         throw ImageReadException(filename, "SER header");
00433                 }
00434                 dict["SER.CalibrationElement"] = cali;
00435 
00436                 short datatype;
00437                 if (fread(&datatype, sizeof(short), 1, serfile) != 1) {
00438                         throw ImageReadException(filename, "SER header");
00439                 }
00440                 dict["SER.DataType"] = datatype;
00441 
00442                 int arrlen;
00443                 if (fread(&arrlen, sizeof(int), 1, serfile) != 1) {
00444                         throw ImageReadException(filename, "SER header");
00445                 }
00446                 dict["nx"] = arrlen;
00447                 dict["ny"] = 1;
00448                 dict["nz"] = 1;
00449 
00450                 nx = arrlen;
00451                 ny = 1;
00452                 nz = 1;
00453         }
00454         else if(this->datatypeid == twoD) {     //2D image
00455                 double hitem4[2];
00456                 if (fread(hitem4, sizeof(double), 2, serfile) != 2) {
00457                         throw ImageReadException(filename, "SER header");
00458                 }
00459                 dict["SER.CalibrationOffsetX"]  = hitem4[0];
00460                 dict["SER.CalibrationDeltaX"]   = hitem4[1];
00461 
00462                 int calix;
00463                 if (fread(&calix, sizeof(int), 1, serfile) != 1) {
00464                         throw ImageReadException(filename, "SER header");
00465                 }
00466                 dict["SER.CalibrationElementX"] = calix;
00467 
00468                 double hitem5[2];
00469                 if (fread(hitem5, sizeof(double), 2, serfile) != 2) {
00470                         throw ImageReadException(filename, "SER header");
00471                 }
00472                 dict["SER.CalibrationOffsetX"]  = hitem5[0];
00473                 dict["SER.CalibrationDeltaX"]   = hitem5[1];
00474 
00475                 int caliy;
00476                 if (fread(&caliy, sizeof(int), 1, serfile) != 1) {
00477                         throw ImageReadException(filename, "SER header");
00478                 }
00479                 dict["SER.CalibrationElementY"] = caliy;
00480 
00481                 short datatype;
00482                 if (fread(&datatype, sizeof(short), 1, serfile) != 1) {
00483                         throw ImageReadException(filename, "SER header");
00484                 }
00485                 dict["SER.DataType"] = datatype;
00486                 this->datamode = datatype;
00487 
00488                 int arrsize[2];
00489                 if (fread(&arrsize, sizeof(int), 2, serfile) != 2) {
00490                         throw ImageReadException(filename, "SER header");
00491                 }
00492                 dict["nx"] = arrsize[0];
00493                 dict["ny"] = arrsize[1];
00494                 dict["nz"] = 1;
00495 
00496                 nx = arrsize[0];
00497                 ny = arrsize[1];
00498                 nz = 1;
00499         }
00500 }

void SerIO::read_data_tag Dict dict  )  [private]
 

helper function to read header attributes in data tag

Definition at line 502 of file serio.cpp.

References filename, ImageReadException, and serfile.

00503 {
00504         int tag_type = (int)dict["SER.TagTypeID"];
00505         if( tag_type == timeOnly ) {
00506                 short tagtype;
00507                 if (fread(&tagtype, sizeof(short), 1, serfile) != 1) {
00508                         throw ImageReadException(filename, "SER header");
00509                 }
00510                 assert((int)tagtype == tag_type);
00511 
00512                 int sertime;
00513                 if (fread(&sertime, sizeof(int), 1, serfile) != 1) {
00514                         throw ImageReadException(filename, "SER header");
00515                 }
00516                 dict["SER.Time"] = sertime;
00517         }
00518         else if( tag_type == posTime ) {
00519                 short tagtype;
00520                 if (fread(&tagtype, sizeof(short), 1, serfile) != 1) {
00521                         throw ImageReadException(filename, "SER header");
00522                 }
00523                 assert((int)tagtype == tag_type);
00524 
00525                 int sertime;
00526                 if (fread(&sertime, sizeof(int), 1, serfile) != 1) {
00527                         throw ImageReadException(filename, "SER header");
00528                 }
00529                 dict["SER.Time"] = sertime;
00530 
00531                 double pos[2];
00532                 if (fread(&pos, sizeof(double), 2, serfile) != 2) {
00533                         throw ImageReadException(filename, "SER header");
00534                 }
00535                 dict["SER.PosionX"] = pos[0];
00536                 dict["SER.PosionY"] = pos[1];
00537         }
00538         else {
00539                 throw ImageReadException(filename, "SER header, wrong TagTypeID");
00540         }
00541 }

void SerIO::read_dim_arr Dict dict,
int  idx
[private]
 

helper function to read attributes in dimension array

Definition at line 359 of file serio.cpp.

References filename, ImageReadException, EMAN::Util::int2str(), and serfile.

00360 {
00361         int dimsize;
00362         if (fread(&dimsize, sizeof(int), 1, serfile) != 1) {
00363                 throw ImageReadException(filename, "SER header");
00364         }
00365 
00366         string sidx = Util::int2str(idx);
00367         dict["SER.DimensionSize"+sidx]  = dimsize;
00368 
00369         double hitem3[2];
00370         if (fread(hitem3, sizeof(double), 2, serfile) != 2) {
00371                 throw ImageReadException(filename, "SER header");
00372         }
00373         dict["SER.CalibrationOffset"+sidx]      = hitem3[0];
00374         dict["SER.CalibrationDelta"+sidx]       = hitem3[1];
00375 
00376         int celement;
00377         if (fread(&celement, sizeof(int), 1, serfile) != 1) {
00378                 throw ImageReadException(filename, "SER header");
00379         }
00380         dict["SER.CalibrationElement"+sidx]     = celement;
00381 
00382         int desclen;
00383         if (fread(&desclen, sizeof(int), 1, serfile) != 1) {
00384                 throw ImageReadException(filename, "SER header");
00385         }
00386         dict["SER.DescriptionLength"+sidx]      = desclen;
00387 
00388         if(desclen != 0) {
00389                 char * descr = new char[desclen+1];
00390                 //char descr[desclen+1];
00391                 if (fread(descr, sizeof(char), desclen, serfile) != (unsigned int)desclen) {
00392                         throw ImageReadException(filename, "SER header");
00393                 }
00394                 descr[desclen] = '\0';
00395                 string sdescr(descr);
00396                 dict["SER.Description"+sidx] = sdescr;
00397                 delete [] descr;
00398         }
00399 
00400         int unitslen;
00401         if (fread(&unitslen, sizeof(int), 1, serfile) != 1) {
00402                 throw ImageReadException(filename, "SER header");
00403         }
00404         dict["SER.UnitsLength"+sidx] = unitslen;
00405 
00406         if(unitslen != 0) {
00407                 char * units = new char[unitslen+1];
00408                 //char units[unitslen+1];
00409                 if (fread(units, sizeof(int), unitslen, serfile) != (unsigned int)unitslen) {
00410                         throw ImageReadException(filename, "SER header");
00411                 }
00412                 units[unitslen] = '\0';
00413                 string sunits(units);
00414                 dict["SER.Units"+sidx] = sunits;
00415                 delete [] units;
00416         }
00417 
00418 }


Member Data Documentation

int* EMAN::SerIO::data_offset_array [private]
 

Definition at line 110 of file serio.h.

Referenced by ~SerIO().

int EMAN::SerIO::datamode [private]
 

Definition at line 117 of file serio.h.

Referenced by read_data_element().

int EMAN::SerIO::datatypeid [private]
 

Definition at line 116 of file serio.h.

Referenced by read_data_element().

EMAN::SerIO::DEFINE_IMAGEIO_FUNC
 

Definition at line 59 of file serio.h.

string EMAN::SerIO::filename [private]
 

Definition at line 102 of file serio.h.

Referenced by get_nimg(), read_data_element(), read_data_tag(), and read_dim_arr().

bool EMAN::SerIO::initialized [private]
 

Definition at line 105 of file serio.h.

bool EMAN::SerIO::is_new_file [private]
 

Definition at line 106 of file serio.h.

int EMAN::SerIO::nimg [private]
 

Definition at line 112 of file serio.h.

int EMAN::SerIO::nx [private]
 

Definition at line 113 of file serio.h.

Referenced by read_data_element().

int EMAN::SerIO::ny [private]
 

Definition at line 114 of file serio.h.

Referenced by read_data_element().

int EMAN::SerIO::nz [private]
 

Definition at line 115 of file serio.h.

IOMode EMAN::SerIO::rw_mode [private]
 

Definition at line 103 of file serio.h.

FILE* EMAN::SerIO::serfile [private]
 

Definition at line 104 of file serio.h.

Referenced by get_nimg(), read_data_element(), read_data_tag(), read_dim_arr(), and ~SerIO().

SerHeader EMAN::SerIO::serh [private]
 

Definition at line 108 of file serio.h.

int* EMAN::SerIO::tag_offset_array [private]
 

Definition at line 111 of file serio.h.

Referenced by ~SerIO().


The documentation for this class was generated from the following files:
Generated on Tue Jun 11 13:43:00 2013 for EMAN2 by  doxygen 1.3.9.1