EMAN::MrcIO Class Reference

MRC file = header + data (nx x ny x nz). More...

#include <mrcio.h>

Inheritance diagram for EMAN::MrcIO:

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

Collaboration graph
[legend]
List of all members.

Public Member Functions

 MrcIO (const string &filename, IOMode rw_mode=READ_ONLY)
 ~MrcIO ()
int read_ctf (Ctf &ctf, int image_index=0)
 Read CTF data from this image.
void write_ctf (const Ctf &ctf, int image_index=0)
 Write CTF data to this image.
int get_nimg ()
 Return the number of images in this image file.

Static Public Member Functions

static bool is_valid (const void *first_block, off_t file_size=0)
static int get_mode_size (int mm)
static int to_em_datatype (int mrcmode)
static int to_mrcmode (int em_datatype, int is_complex)

Public Attributes

 DEFINE_IMAGEIO_FUNC

Private Types

 MRC_UCHAR = 0
 MRC_SHORT
 MRC_FLOAT
 MRC_SHORT_COMPLEX
 MRC_FLOAT_COMPLEX
 MRC_USHORT = 6
 MRC_UCHAR3 = 16
 MRC_UNKNOWN
 MRC_NUM_LABELS = 10
 MRC_LABEL_SIZE = 80
 NUM_4BYTES_PRE_MAP = 52
 NUM_4BYTES_AFTER_MAP = 3
enum  MrcMode {
  MRC_UCHAR = 0, MRC_SHORT, MRC_FLOAT, MRC_SHORT_COMPLEX,
  MRC_FLOAT_COMPLEX, MRC_USHORT = 6, MRC_UCHAR3 = 16, MRC_UNKNOWN
}
enum  { MRC_NUM_LABELS = 10, MRC_LABEL_SIZE = 80, NUM_4BYTES_PRE_MAP = 52, NUM_4BYTES_AFTER_MAP = 3 }

Private Member Functions

void swap_header (MrcHeader &mrch)
void update_stat (void *data)
 This is a utility function used to calculate new min/max/mean/sigma when write MRC file as 16 bit or 8 bit.
int read_mrc_header (Dict &dict, int image_index=0, const Region *area=0, bool is_3d=false)
int read_fei_header (Dict &dict, int image_index=0, const Region *area=0, bool is_3d=false)

Static Private Member Functions

static int generate_machine_stamp ()
 generate the machine stamp used in MRC image format.

Private Attributes

string filename
IOMode rw_mode
FILE * mrcfile
int mode_size
union {
   MrcHeader   mrch
   FeiMrcHeader   feimrch
}; 
bool isFEI
int is_ri
bool is_big_endian
bool is_new_file
bool initialized

Static Private Attributes

static const char * CTF_MAGIC = "!-"
static const char * SHORT_CTF_MAGIC = "!$"

Classes

struct  FeiMrcExtHeader
 The extended header used by Fei MRC image. More...
struct  FeiMrcHeader
 Extended MRC format for tomography As used by Fei; original definition of extended header by Dave Agard and Bram Koster Contact Dustin Morado <Dustin.Morado@uth.tmc.edu> for details. More...
struct  MrcHeader

Detailed Description

MRC file = header + data (nx x ny x nz).

A MRC image file stores 1D, 2D or 3D image. The image's dimensions and pixel type are defined in the header.

Definition at line 48 of file mrcio.h.


Member Enumeration Documentation

anonymous enum [private]

Enumerator:
MRC_NUM_LABELS 
MRC_LABEL_SIZE 
NUM_4BYTES_PRE_MAP 
NUM_4BYTES_AFTER_MAP 

Definition at line 78 of file mrcio.h.

00078                      {
00079                         MRC_NUM_LABELS = 10,
00080                         MRC_LABEL_SIZE = 80,
00081                         NUM_4BYTES_PRE_MAP = 52,
00082                         NUM_4BYTES_AFTER_MAP = 3
00083                 };

enum EMAN::MrcIO::MrcMode [private]

Enumerator:
MRC_UCHAR 
MRC_SHORT 
MRC_FLOAT 
MRC_SHORT_COMPLEX 
MRC_FLOAT_COMPLEX 
MRC_USHORT 
MRC_UCHAR3 
MRC_UNKNOWN 

Definition at line 67 of file mrcio.h.

00067                              {
00068                         MRC_UCHAR = 0,
00069                         MRC_SHORT,
00070                         MRC_FLOAT,
00071                         MRC_SHORT_COMPLEX,
00072                         MRC_FLOAT_COMPLEX,
00073                         MRC_USHORT = 6,         //non-standard
00074                         MRC_UCHAR3 = 16,        //unsigned char * 3, for rgb data, non-standard
00075                         MRC_UNKNOWN
00076                 };


Constructor & Destructor Documentation

MrcIO::MrcIO ( const string &  filename,
IOMode  rw_mode = READ_ONLY 
) [explicit]

Definition at line 51 of file mrcio.cpp.

References is_big_endian, EMAN::ByteOrder::is_host_big_endian(), and mrch.

00052 :       filename(mrc_filename), rw_mode(rw), mrcfile(0), mode_size(0),
00053                 isFEI(false), is_ri(0), is_new_file(false), initialized(false)
00054 {
00055         memset(&mrch, 0, sizeof(MrcHeader));
00056         is_big_endian = ByteOrder::is_host_big_endian();
00057 }

MrcIO::~MrcIO (  ) 

Definition at line 59 of file mrcio.cpp.

References mrcfile.

00060 {
00061         if (mrcfile) {
00062                 fclose(mrcfile);
00063                 mrcfile = 0;
00064         }
00065 }


Member Function Documentation

int MrcIO::generate_machine_stamp (  )  [static, private]

generate the machine stamp used in MRC image format.

Definition at line 1174 of file mrcio.cpp.

References EMAN::ByteOrder::is_host_big_endian().

01175 {
01176         int stamp = 0;
01177         char *p = (char *) (&stamp);
01178 
01179         if (ByteOrder::is_host_big_endian()) {
01180                 p[0] = 0x11;
01181                 p[1] = 0x11;
01182                 p[2] = 0;
01183                 p[3] = 0;
01184         }
01185         else {
01186                 p[0] = 0x44;
01187                 p[1] = 0x41;
01188                 p[2] = 0;
01189                 p[3] = 0;
01190         }
01191         return stamp;
01192 }

int MrcIO::get_mode_size ( int  mm  )  [static]

Definition at line 1067 of file mrcio.cpp.

References MRC_FLOAT, MRC_FLOAT_COMPLEX, MRC_SHORT, MRC_SHORT_COMPLEX, MRC_UCHAR, and MRC_USHORT.

Referenced by is_valid().

01068 {
01069         MrcIO::MrcMode m = static_cast < MrcMode > (mm);
01070 
01071         int msize = 0;
01072         switch (m) {
01073         case MRC_UCHAR:
01074                 msize = sizeof(char);
01075                 break;
01076         case MRC_SHORT:
01077         case MRC_USHORT:
01078         case MRC_SHORT_COMPLEX:
01079                 msize = sizeof(short);
01080                 break;
01081         case MRC_FLOAT:
01082         case MRC_FLOAT_COMPLEX:
01083                 msize = sizeof(float);
01084                 break;
01085         default:
01086                 msize = 0;
01087         }
01088 
01089         return msize;
01090 }

int MrcIO::get_nimg (  )  [virtual]

Return the number of images in this image file.

Reimplemented from EMAN::ImageIO.

Definition at line 1200 of file mrcio.cpp.

References feimrch, EMAN::ImageIO::init(), isFEI, and EMAN::MrcIO::FeiMrcHeader::nz.

01201 {
01202         init();
01203 
01204         if(isFEI) {
01205                 return feimrch.nz;
01206         }
01207         else {
01208                 return 1;
01209         }
01210 }

bool MrcIO::is_valid ( const void *  first_block,
off_t  file_size = 0 
) [static]

Definition at line 134 of file mrcio.cpp.

References data, ENTERFUNC, EXITFUNC, get_mode_size(), EMAN::ByteOrder::is_data_big_endian(), EMAN::ByteOrder::is_host_big_endian(), LOGWARN, MRC_FLOAT_COMPLEX, MRC_SHORT_COMPLEX, MRC_UCHAR, MRC_UNKNOWN, nx, ny, and EMAN::ByteOrder::swap_bytes().

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

00135 {
00136         ENTERFUNC;
00137 
00138         if (!first_block) {
00139                 return false;
00140         }
00141 
00142         const int *data = static_cast < const int *>(first_block);
00143         int nx = data[0];
00144         int ny = data[1];
00145         int nz = data[2];
00146         int mrcmode = data[3];
00147         int nsymbt = data[23];  //this field specify the extra bytes for symmetry information
00148 
00149         bool data_big_endian = ByteOrder::is_data_big_endian(&nz);
00150 
00151         if (data_big_endian != ByteOrder::is_host_big_endian()) {
00152                 ByteOrder::swap_bytes(&nx);
00153                 ByteOrder::swap_bytes(&ny);
00154                 ByteOrder::swap_bytes(&nz);
00155                 ByteOrder::swap_bytes(&mrcmode);
00156                 ByteOrder::swap_bytes(&nsymbt);
00157         }
00158 
00159         if (mrcmode == MRC_SHORT_COMPLEX || mrcmode == MRC_FLOAT_COMPLEX) {
00160                 nx *= 2;
00161         }
00162 
00163         const int max_dim = 1 << 20;
00164 
00165         if ((mrcmode >= MRC_UCHAR && mrcmode < MRC_UNKNOWN) &&
00166                 (nx > 1 && nx < max_dim) && (ny > 0 && ny < max_dim) && (nz > 0 && nz < max_dim)) {
00167 //#ifndef SPIDERMRC // Spider MRC files don't satisfy the following test
00168                 if (file_size > 0) {
00169                         off_t file_size1 = (off_t)nx * (off_t)ny * (off_t)nz * (off_t)get_mode_size(mrcmode) + (off_t)sizeof(MrcHeader) + nsymbt;
00170                         if (file_size == file_size1) {
00171                                 return true;
00172                         }
00173 //                      return false;
00174                         LOGWARN("image size check fails, still try to read it...");     //when size doesn't match, print error message instead of make it fail
00175                 }
00176                 else {
00177                         return true;
00178                 }
00179 //#endif // SPIDERMRC
00180                 return true;
00181         }
00182         EXITFUNC;
00183         return false;
00184 }

int MrcIO::read_ctf ( Ctf ctf,
int  image_index = 0 
) [virtual]

Read CTF data from this image.

Parameters:
ctf Used to store the CTF data.
image_index The index of the image to read.
Returns:
0 if OK; 1 if error.

Reimplemented from EMAN::ImageIO.

Definition at line 1032 of file mrcio.cpp.

References CTF_MAGIC, ENTERFUNC, EXITFUNC, EMAN::Ctf::from_string(), and EMAN::ImageIO::init().

Referenced by read_mrc_header().

01033 {
01034         ENTERFUNC;
01035         init();
01036         size_t n = strlen(CTF_MAGIC);
01037 
01038         int err = 1;
01039         if (strncmp(&mrch.labels[0][0], CTF_MAGIC, n) == 0) {
01040                 err = ctf.from_string(string(&mrch.labels[0][n]));
01041         }
01042         EXITFUNC;
01043         return err;
01044 }

int MrcIO::read_fei_header ( Dict dict,
int  image_index = 0,
const Region area = 0,
bool  is_3d = false 
) [private]

Definition at line 317 of file mrcio.cpp.

References EMAN::MrcIO::FeiMrcExtHeader::a_tilt, EMAN::MrcIO::FeiMrcHeader::alpha, EMAN::MrcIO::FeiMrcHeader::amax, EMAN::MrcIO::FeiMrcHeader::amean, EMAN::MrcIO::FeiMrcHeader::amin, EMAN::MrcIO::FeiMrcExtHeader::appliedDefocus, EMAN::MrcIO::FeiMrcExtHeader::b_tilt, EMAN::MrcIO::FeiMrcHeader::beta, EMAN::MrcIO::FeiMrcExtHeader::binning, EMAN::ImageIO::check_region(), EMAN::MrcIO::FeiMrcExtHeader::defocus, EMAN::MrcIO::FeiMrcHeader::dvid, ENTERFUNC, EXITFUNC, EMAN::MrcIO::FeiMrcExtHeader::exp_time, feimrch, filename, EMAN::MrcIO::FeiMrcHeader::gamma, EMAN::Region::get_depth(), EMAN::EMUtil::get_region_dims(), EMAN::MrcIO::FeiMrcExtHeader::ht, EMAN::MrcIO::FeiMrcHeader::idtype, ImageDimensionException, ImageReadException, EMAN::ImageIO::init(), is_new_file, EMAN::MrcIO::FeiMrcHeader::ispg, EMAN::MrcIO::FeiMrcHeader::labl, EMAN::MrcIO::FeiMrcHeader::lens, EMAN::MrcIO::FeiMrcExtHeader::magnification, EMAN::MrcIO::FeiMrcHeader::mapc, EMAN::MrcIO::FeiMrcHeader::mapr, EMAN::MrcIO::FeiMrcHeader::maps, EMAN::MrcIO::FeiMrcHeader::max2, EMAN::MrcIO::FeiMrcHeader::max3, EMAN::MrcIO::FeiMrcHeader::max4, EMAN::MrcIO::FeiMrcExtHeader::mean_int, EMAN::MrcIO::FeiMrcHeader::min2, EMAN::MrcIO::FeiMrcHeader::min3, EMAN::MrcIO::FeiMrcHeader::min4, EMAN::MrcIO::FeiMrcHeader::mode, mrcfile, EMAN::MrcIO::FeiMrcHeader::mx, EMAN::MrcIO::FeiMrcHeader::my, EMAN::MrcIO::FeiMrcHeader::mz, EMAN::MrcIO::FeiMrcHeader::nd1, EMAN::MrcIO::FeiMrcHeader::nd2, EMAN::MrcIO::FeiMrcHeader::next, EMAN::MrcIO::FeiMrcHeader::nlabl, EMAN::MrcIO::FeiMrcHeader::nsymbt, EMAN::MrcIO::FeiMrcHeader::numfloats, EMAN::MrcIO::FeiMrcHeader::numintegers, EMAN::MrcIO::FeiMrcHeader::nx, EMAN::MrcIO::FeiMrcHeader::nxstart, EMAN::MrcIO::FeiMrcHeader::ny, EMAN::MrcIO::FeiMrcHeader::nystart, EMAN::MrcIO::FeiMrcHeader::nz, EMAN::MrcIO::FeiMrcHeader::nzstart, EMAN::MrcIO::FeiMrcExtHeader::pixel_size, portable_fseek(), EMAN::MrcIO::FeiMrcHeader::sub, EMAN::MrcIO::FeiMrcExtHeader::tilt_axis, EMAN::MrcIO::FeiMrcHeader::tiltangles, to_em_datatype(), EMAN::MrcIO::FeiMrcHeader::vd1, EMAN::MrcIO::FeiMrcHeader::vd2, EMAN::MrcIO::FeiMrcExtHeader::x_shift, EMAN::MrcIO::FeiMrcExtHeader::x_stage, EMAN::MrcIO::FeiMrcHeader::xlen, EMAN::MrcIO::FeiMrcHeader::xorg, EMAN::MrcIO::FeiMrcExtHeader::y_shift, EMAN::MrcIO::FeiMrcExtHeader::y_stage, EMAN::MrcIO::FeiMrcHeader::ylen, EMAN::MrcIO::FeiMrcHeader::yorg, EMAN::MrcIO::FeiMrcExtHeader::z_stage, EMAN::MrcIO::FeiMrcHeader::zfac, EMAN::MrcIO::FeiMrcHeader::zlen, and EMAN::MrcIO::FeiMrcHeader::zorg.

00318 {
00319         ENTERFUNC;
00320 
00321         if(image_index < 0) {
00322                 image_index = 0;
00323         }
00324 
00325         if(area && area->get_depth() > 1) {
00326                 throw ImageDimensionException("FEI MRC image is 2D tile series, only 2D regional reading accepted.");
00327         }
00328 
00329         init();
00330 
00331         check_region(area, FloatSize(feimrch.nx, feimrch.ny, feimrch.nz), is_new_file,false);
00332 
00333         int xlen = 0, ylen = 0, zlen = 0;
00334         EMUtil::get_region_dims(area, feimrch.nx, &xlen, feimrch.ny, &ylen, feimrch.nz, &zlen);
00335 
00336         dict["nx"] = xlen;
00337         dict["ny"] = ylen;
00338         dict["nz"] = 1; //only read one 2D image from a tilt series
00339         dict["FEIMRC.nx"] = feimrch.nx;
00340         dict["FEIMRC.ny"] = feimrch.ny;
00341         dict["FEIMRC.nz"] = feimrch.nz;
00342 
00343         dict["datatype"] = to_em_datatype(feimrch.mode);        //=1, FEI-MRC file always use short for data type
00344 
00345         dict["FEIMRC.nxstart"] = feimrch.nxstart;
00346         dict["FEIMRC.nystart"] = feimrch.nystart;
00347         dict["FEIMRC.nzstart"] = feimrch.nzstart;
00348 
00349         dict["FEIMRC.mx"] = feimrch.mx;
00350         dict["FEIMRC.my"] = feimrch.my;
00351         dict["FEIMRC.mz"] = feimrch.mz;
00352 
00353         dict["FEIMRC.xlen"] = feimrch.xlen;
00354         dict["FEIMRC.ylen"] = feimrch.ylen;
00355         dict["FEIMRC.zlen"] = feimrch.zlen;
00356 
00357         dict["FEIMRC.alpha"] = feimrch.alpha;
00358         dict["FEIMRC.beta"] = feimrch.beta;
00359         dict["FEIMRC.gamma"] = feimrch.gamma;
00360 
00361         dict["FEIMRC.mapc"] = feimrch.mapc;
00362         dict["FEIMRC.mapr"] = feimrch.mapr;
00363         dict["FEIMRC.maps"] = feimrch.maps;
00364 
00365         dict["FEIMRC.minimum"] = feimrch.amin;
00366         dict["FEIMRC.maximum"] = feimrch.amax;
00367         dict["FEIMRC.mean"] = feimrch.amean;
00368         dict["mean"] = feimrch.amean;
00369 
00370         dict["FEIMRC.ispg"] = feimrch.ispg;
00371         dict["FEIMRC.nsymbt"] = feimrch.nsymbt;
00372 
00373         dict["apix_x"] = feimrch.xlen / feimrch.mx;
00374         dict["apix_y"] = feimrch.ylen / feimrch.my;
00375         dict["apix_z"] = feimrch.zlen / feimrch.mz;
00376 
00377         dict["FEIMRC.next"] = feimrch.next;     //offset from end of header to the first dataset
00378         dict["FEIMRC.dvid"] = feimrch.dvid;
00379         dict["FEIMRC.numintegers"] = feimrch.numintegers;
00380         dict["FEIMRC.numfloats"] = feimrch.numfloats;
00381         dict["FEIMRC.sub"] = feimrch.sub;
00382         dict["FEIMRC.zfac"] = feimrch.zfac;
00383 
00384         dict["FEIMRC.min2"] = feimrch.min2;
00385         dict["FEIMRC.max2"] = feimrch.max2;
00386         dict["FEIMRC.min3"] = feimrch.min3;
00387         dict["FEIMRC.max3"] = feimrch.max3;
00388         dict["FEIMRC.min4"] = feimrch.min4;
00389         dict["FEIMRC.max4"] = feimrch.max4;
00390 
00391         dict["FEIMRC.idtype"] = feimrch.idtype;
00392         dict["FEIMRC.lens"] = feimrch.lens;
00393         dict["FEIMRC.nd1"] = feimrch.nd1;
00394         dict["FEIMRC.nd2"] = feimrch.nd2;
00395         dict["FEIMRC.vd1"] = feimrch.vd1;
00396         dict["FEIMRC.vd2"] = feimrch.vd2;
00397 
00398         for(int i=0; i<9; i++) {        //9 tilt angles
00399                 char label[32];
00400                 sprintf(label, "MRC.tiltangles%d", i);
00401                 dict[string(label)] = feimrch.tiltangles[i];
00402         }
00403 
00404         dict["FEIMRC.zorg"] = feimrch.zorg;
00405         dict["FEIMRC.xorg"] = feimrch.xorg;
00406         dict["FEIMRC.yorg"] = feimrch.yorg;
00407 
00408         dict["FEIMRC.nlabl"] = feimrch.nlabl;
00409         for (int i = 0; i < feimrch.nlabl; i++) {
00410                 char label[32];
00411                 sprintf(label, "MRC.label%d", i);
00412                 dict[string(label)] = string(feimrch.labl[i], 80);
00413         }
00414 
00415         /* Read extended image header by specified image index*/
00416         FeiMrcExtHeader feiexth;
00417         portable_fseek(mrcfile, sizeof(FeiMrcHeader)+sizeof(FeiMrcExtHeader)*image_index, SEEK_SET);
00418         if (fread(&feiexth, sizeof(FeiMrcExtHeader), 1, mrcfile) != 1) {
00419                 throw ImageReadException(filename, "FEI MRC extended header");
00420         }
00421 
00422         dict["FEIMRC.a_tilt"] = feiexth.a_tilt;
00423         dict["FEIMRC.b_tilt"] = feiexth.b_tilt;
00424 
00425         dict["FEIMRC.x_stage"] = feiexth.x_stage;
00426         dict["FEIMRC.y_stage"] = feiexth.y_stage;
00427         dict["FEIMRC.z_stage"] = feiexth.z_stage;
00428 
00429         dict["FEIMRC.x_shift"] = feiexth.x_shift;
00430         dict["FEIMRC.y_shift"] = feiexth.y_shift;
00431 
00432         dict["FEIMRC.defocus"] = feiexth.defocus;
00433         dict["FEIMRC.exp_time"] = feiexth.exp_time;
00434         dict["FEIMRC.mean_int"] = feiexth.mean_int;
00435         dict["FEIMRC.tilt_axis"] = feiexth.tilt_axis;
00436 
00437         dict["FEIMRC.pixel_size"] = feiexth.pixel_size;
00438         dict["FEIMRC.magnification"] = feiexth.magnification;
00439         dict["FEIMRC.ht"] = feiexth.ht;
00440         dict["FEIMRC.binning"] = feiexth.binning;
00441         dict["FEIMRC.appliedDefocus"] = feiexth.appliedDefocus;
00442 
00443         //remainder 16 4-byte floats not used
00444 
00445         EXITFUNC;
00446         return 0;
00447 }

int MrcIO::read_mrc_header ( Dict dict,
int  image_index = 0,
const Region area = 0,
bool  is_3d = false 
) [private]

Definition at line 198 of file mrcio.cpp.

References EMAN::ImageIO::check_region(), ENTERFUNC, EXITFUNC, filename, EMAN::Region::get_ndim(), EMAN::EMUtil::get_region_dims(), ImageReadException, EMAN::ImageIO::is_complex_mode(), is_new_file, EMAN::Region::origin, EMAN::Dict::put(), read_ctf(), to_em_datatype(), and EMAN::EMAN1Ctf::to_vector().

00199 {
00200         ENTERFUNC;
00201 
00202         //single image format, index can only be zero
00203         if(image_index < 0) {
00204                 image_index = 0;
00205         }
00206         if(image_index != 0) {
00207                 throw ImageReadException(filename, "no stack allowed for MRC image. For take 2D slice out of 3D image, read the 3D image first, then use get_clip().");
00208         }
00209 
00210         check_region(area, FloatSize(mrch.nx, mrch.ny, mrch.nz), is_new_file,false);
00211 
00212         int xlen = 0, ylen = 0, zlen = 0;
00213         EMUtil::get_region_dims(area, mrch.nx, &xlen, mrch.ny, &ylen, mrch.nz, &zlen);
00214 
00215         dict["nx"] = xlen;
00216         dict["ny"] = ylen;
00217         dict["nz"] = zlen;
00218         dict["MRC.nx"] = mrch.nx;
00219         dict["MRC.ny"] = mrch.ny;
00220         dict["MRC.nz"] = mrch.nz;
00221 
00222         dict["datatype"] = to_em_datatype(mrch.mode);
00223 
00224         dict["MRC.nxstart"] = mrch.nxstart;
00225         dict["MRC.nystart"] = mrch.nystart;
00226         dict["MRC.nzstart"] = mrch.nzstart;
00227 
00228         dict["MRC.mx"] = mrch.mx;
00229         dict["MRC.my"] = mrch.my;
00230         dict["MRC.mz"] = mrch.mz;
00231 
00232         dict["MRC.xlen"] = mrch.xlen;
00233         dict["MRC.ylen"] = mrch.ylen;
00234         dict["MRC.zlen"] = mrch.zlen;
00235 
00236         dict["MRC.alpha"] = mrch.alpha;
00237         dict["MRC.beta"] = mrch.beta;
00238         dict["MRC.gamma"] = mrch.gamma;
00239 
00240         dict["MRC.mapc"] = mrch.mapc;
00241         dict["MRC.mapr"] = mrch.mapr;
00242         dict["MRC.maps"] = mrch.maps;
00243 
00244         dict["MRC.minimum"] = mrch.amin;
00245         dict["MRC.maximum"] = mrch.amax;
00246         dict["MRC.mean"] = mrch.amean;
00247         dict["mean"] = mrch.amean;
00248 
00249         dict["MRC.ispg"] = mrch.ispg;
00250         dict["MRC.nsymbt"] = mrch.nsymbt;
00251 
00252         dict["apix_x"] = mrch.xlen / mrch.mx;
00253         dict["apix_y"] = mrch.ylen / mrch.my;
00254         dict["apix_z"] = mrch.zlen / mrch.mz;
00255 
00256         if (area) {
00257                 dict["origin_x"] = mrch.xorigin + mrch.xlen * area->origin[0];
00258                 dict["origin_y"] = mrch.yorigin + mrch.xlen * area->origin[1];
00259 
00260                 if (area->get_ndim() == 3 && mrch.nz > 1) {
00261                         dict["origin_z"] = mrch.zorigin + mrch.xlen * area->origin[2];
00262                 }
00263                 else {
00264                         dict["origin_z"] = mrch.zorigin;
00265                 }
00266         }
00267         else {
00268                 dict["origin_x"] = mrch.xorigin;
00269                 dict["origin_y"] = mrch.yorigin;
00270                 dict["origin_z"] = mrch.zorigin;
00271         }
00272 
00273         if (is_complex_mode()) {
00274                 dict["is_complex"] = 1;
00275                 dict["is_complex_ri"] = 1;
00276         }
00277 
00278         dict["MRC.machinestamp"] = mrch.machinestamp;
00279 
00280         dict["MRC.rms"] = mrch.rms;
00281         dict["sigma"] = mrch.rms;
00282         dict["MRC.nlabels"] = mrch.nlabels;
00283         for (int i = 0; i < mrch.nlabels; i++) {
00284                 char label[32];
00285                 sprintf(label, "MRC.label%d", i);
00286                 dict[string(label)] = string(mrch.labels[i],80);
00287         }
00288 
00289         EMAN1Ctf ctf_;
00290         if(read_ctf(ctf_) == 0) {
00291                 vector<float> vctf = ctf_.to_vector();
00292                 dict["ctf"] = vctf;
00293         }
00294 
00295         Dict dic;
00296         dic.put("type", "imagic");
00297         dic.put("alpha", mrch.alpha);
00298         dic.put("beta", mrch.beta);
00299         dic.put("gamma", mrch.gamma);
00300         dic.put("tx", mrch.xorigin);
00301         dic.put("ty", mrch.yorigin);
00302         dic.put("tz", mrch.zorigin);
00303         Transform * trans = new Transform(dic);
00304         if(zlen<=1) {
00305                 dict["xform.projection"] = trans;
00306         }
00307         else {
00308                 dict["xform.align3d"] = trans;
00309         }
00310 
00311         if(trans) {delete trans; trans=0;}
00312 
00313         EXITFUNC;
00314         return 0;
00315 }

void MrcIO::swap_header ( MrcHeader mrch  )  [private]

Definition at line 1194 of file mrcio.cpp.

References mrch, NUM_4BYTES_AFTER_MAP, NUM_4BYTES_PRE_MAP, and EMAN::ByteOrder::swap_bytes().

int MrcIO::to_em_datatype ( int  mrcmode  )  [static]

Definition at line 1092 of file mrcio.cpp.

References EMAN::EMUtil::EM_FLOAT, EMAN::EMUtil::EM_FLOAT_COMPLEX, EMAN::EMUtil::EM_SHORT, EMAN::EMUtil::EM_SHORT_COMPLEX, EMAN::EMUtil::EM_UCHAR, EMAN::EMUtil::EM_UNKNOWN, EMAN::EMUtil::EM_USHORT, MRC_FLOAT, MRC_FLOAT_COMPLEX, MRC_SHORT, MRC_SHORT_COMPLEX, MRC_UCHAR, and MRC_USHORT.

Referenced by read_fei_header(), and read_mrc_header().

01093 {
01094         EMUtil::EMDataType e = EMUtil::EM_UNKNOWN;
01095 
01096         switch (m) {
01097         case MRC_UCHAR:
01098                 e = EMUtil::EM_UCHAR;
01099                 break;
01100         case MRC_SHORT:
01101                 e = EMUtil::EM_SHORT;
01102                 break;
01103         case MRC_USHORT:
01104                 e = EMUtil::EM_USHORT;
01105                 break;
01106         case MRC_SHORT_COMPLEX:
01107                 e = EMUtil::EM_SHORT_COMPLEX;
01108                 break;
01109         case MRC_FLOAT:
01110                 e = EMUtil::EM_FLOAT;
01111                 break;
01112         case MRC_FLOAT_COMPLEX:
01113                 e = EMUtil::EM_FLOAT_COMPLEX;
01114                 break;
01115         default:
01116                 e = EMUtil::EM_UNKNOWN;
01117         }
01118         return e;
01119 }

int MrcIO::to_mrcmode ( int  em_datatype,
int  is_complex 
) [static]

Definition at line 1122 of file mrcio.cpp.

References EMAN::EMUtil::EM_CHAR, EMAN::EMUtil::EM_FLOAT, EMAN::EMUtil::EM_FLOAT_COMPLEX, EMAN::EMUtil::EM_INT, EMAN::EMUtil::EM_SHORT, EMAN::EMUtil::EM_SHORT_COMPLEX, EMAN::EMUtil::EM_UCHAR, EMAN::EMUtil::EM_UINT, EMAN::EMUtil::EM_USHORT, EMAN::EMUtil::EM_USHORT_COMPLEX, MRC_FLOAT, MRC_FLOAT_COMPLEX, MRC_SHORT, MRC_SHORT_COMPLEX, MRC_UCHAR, MRC_UNKNOWN, and MRC_USHORT.

01123 {
01124         MrcMode m = MRC_UNKNOWN;
01125         EMUtil::EMDataType em_type = static_cast < EMUtil::EMDataType > (e);
01126 
01127         switch (em_type) {
01128         case EMUtil::EM_UCHAR:
01129                 m = MRC_UCHAR;
01130                 break;
01131         case EMUtil::EM_USHORT:
01132                 if (is_complex) {
01133                         m = MRC_SHORT_COMPLEX;
01134                 }
01135                 else {
01136                         m = MRC_USHORT;
01137                 }
01138                 break;
01139         case EMUtil::EM_SHORT:
01140                 if (is_complex) {
01141                         m = MRC_SHORT_COMPLEX;
01142                 }
01143                 else {
01144                         m = MRC_SHORT;
01145                 }
01146                 break;
01147         case EMUtil::EM_SHORT_COMPLEX:
01148         case EMUtil::EM_USHORT_COMPLEX:
01149                 m = MRC_SHORT_COMPLEX;
01150                 break;
01151         case EMUtil::EM_CHAR:
01152         case EMUtil::EM_INT:
01153         case EMUtil::EM_UINT:
01154         case EMUtil::EM_FLOAT:
01155                 if (is_complex) {
01156                         m = MRC_FLOAT_COMPLEX;
01157                 }
01158                 else {
01159                         m = MRC_FLOAT;
01160                 }
01161                 break;
01162         case EMUtil::EM_FLOAT_COMPLEX:
01163                 m = MRC_FLOAT_COMPLEX;
01164                 break;
01165         default:
01166                 m = MRC_FLOAT;
01167         }
01168 
01169         return m;
01170 }

void MrcIO::update_stat ( void *  data  )  [private]

This is a utility function used to calculate new min/max/mean/sigma when write MRC file as 16 bit or 8 bit.

It will write new set of min/max/mean/sigma to mrch. this function needs get the output data storage type from mrch.mode.

Definition at line 909 of file mrcio.cpp.

References filename, ImageWriteException, InvalidCallException, max, mean(), min, MRC_SHORT, MRC_SHORT_COMPLEX, MRC_UCHAR, MRC_USHORT, mrcfile, portable_fseek(), sqrt(), and v.

00910 {
00911         size_t size =  mrch.nx * mrch.ny * mrch.nz;
00912         float v = 0.0f; //variable to hold pixel value
00913         double sum = 0.0;
00914         double square_sum = 0.0;
00915         double mean = 0.0;
00916         float min, max;
00917         
00918         unsigned char * cdata = 0;
00919         short * sdata = 0;
00920         unsigned short * usdata = 0;
00921         
00922         if (mrch.mode == MRC_UCHAR) {
00923                 max = 0.0f;
00924                 min = UCHAR_MAX;
00925                 cdata = (unsigned char *)data;
00926                 
00927                 for (size_t i = 0; i < size; ++i) {
00928                         v = (float)(cdata[i]);
00929 #ifdef _WIN32
00930                         max = _cpp_max(max,v);
00931                         min = _cpp_min(min,v);
00932 #else
00933                         max=std::max<float>(max,v);
00934                         min=std::min<float>(min,v);
00935 #endif  //_WIN32
00936                         
00937                         sum += v;
00938                         square_sum += v * v;
00939                 }
00940         }
00941         else if (mrch.mode == MRC_SHORT || mrch.mode == MRC_SHORT_COMPLEX) {
00942                 max = (float)SHRT_MIN;
00943                 min = (float)SHRT_MAX;
00944                 sdata = (short *)data;
00945                 
00946                 for (size_t i = 0; i < size; ++i) {
00947                         v = (float)(sdata[i]);
00948 #ifdef _WIN32
00949                         max = _cpp_max(max,v);
00950                         min = _cpp_min(min,v);
00951 #else
00952                         max=std::max<float>(max,v);
00953                         min=std::min<float>(min,v);
00954 #endif  //_WIN32
00955                         
00956                         sum += v;
00957                         square_sum += v * v;
00958                 }
00959         }
00960         else if (mrch.mode == MRC_USHORT) {
00961                 max = 0.0f;
00962                 min = (float)USHRT_MAX;
00963                 usdata = (unsigned short*)data;
00964                 
00965                 for (size_t i = 0; i < size; ++i) {
00966                         v = (float)(usdata[i]);
00967 #ifdef _WIN32
00968                         max = _cpp_max(max,v);
00969                         min = _cpp_min(min,v);
00970 #else
00971                         max=std::max<float>(max,v);
00972                         min=std::min<float>(min,v);
00973 #endif  //_WIN32
00974                         
00975                         sum += v;
00976                         square_sum += v * v;
00977                 }
00978         }
00979         else {
00980                 throw InvalidCallException("This function is used to write 8bit/16bit mrc file only.");
00981         }
00982         
00983         mean = sum/size;
00984 #ifdef _WIN32
00985         float sigma = (float)std::sqrt( _cpp_max(0.0,(square_sum - sum*sum / size)/(size-1)));
00986 #else
00987         float sigma = (float)std::sqrt(std::max<float>(0.0,(square_sum - sum*sum / size)/(size-1)));
00988 #endif  //_WIN32
00989 
00990         /*change mrch.amin/amax/amean.rms here*/
00991         mrch.amin = min;
00992         mrch.amax = max;
00993         mrch.amean = (float)mean;
00994         mrch.rms = sigma;
00995         
00996         MrcHeader mrch2 = mrch;
00997 
00998 //endian issue, can't get use_host_endian argument
00999 //      bool opposite_endian = false;
01000 
01001 //      if (!is_new_file) {
01002 //              if (is_big_endian != ByteOrder::is_host_big_endian()) {
01003 //                      opposite_endian = true;
01004 //              }
01005 //
01006 //              portable_fseek(mrcfile, 0, SEEK_SET);
01007 //      }
01008 //      
01009 //      if (opposite_endian || !use_host_endian) {
01010 //              swap_header(mrch2);
01011 //      }
01012 
01013         portable_fseek(mrcfile, 0, SEEK_SET);
01014         
01015         if (fwrite(&mrch2, sizeof(MrcHeader), 1, mrcfile) != 1) {
01016                 throw ImageWriteException(filename, "MRC header");
01017         }
01018         
01019         portable_fseek(mrcfile, sizeof(MrcHeader), SEEK_SET);
01020 }

void MrcIO::write_ctf ( const Ctf ctf,
int  image_index = 0 
) [virtual]

Write CTF data to this image.

Parameters:
ctf Ctf instance storing the CTF data.
image_index The index of the image to write.
Returns:
0 if OK; 1 if error.

Reimplemented from EMAN::ImageIO.

Definition at line 1046 of file mrcio.cpp.

References CTF_MAGIC, ENTERFUNC, EXITFUNC, filename, ImageWriteException, EMAN::ImageIO::init(), mrcfile, and EMAN::Ctf::to_string().

01047 {
01048         ENTERFUNC;
01049         init();
01050 
01051         string ctf_str = ctf.to_string();
01052         sprintf(&mrch.labels[0][0], "%s%s", CTF_MAGIC, ctf_str.c_str());
01053         rewind(mrcfile);
01054 
01055         if (fwrite(&mrch, sizeof(MrcHeader), 1, mrcfile) != 1) {
01056                 throw ImageWriteException(filename, "write CTF info to header failed");
01057         }
01058         EXITFUNC;
01059 }


Member Data Documentation

union { ... } [private]

const char * MrcIO::CTF_MAGIC = "!-" [static, private]

Definition at line 260 of file mrcio.h.

Referenced by read_ctf(), and write_ctf().

EMAN::MrcIO::DEFINE_IMAGEIO_FUNC

Definition at line 54 of file mrcio.h.

FeiMrcHeader EMAN::MrcIO::feimrch [private]

Definition at line 272 of file mrcio.h.

Referenced by get_nimg(), and read_fei_header().

string EMAN::MrcIO::filename [private]

Definition at line 265 of file mrcio.h.

Referenced by read_fei_header(), read_mrc_header(), update_stat(), and write_ctf().

bool EMAN::MrcIO::initialized [private]

Definition at line 281 of file mrcio.h.

bool EMAN::MrcIO::is_big_endian [private]

Definition at line 279 of file mrcio.h.

Referenced by MrcIO().

bool EMAN::MrcIO::is_new_file [private]

Definition at line 280 of file mrcio.h.

Referenced by read_fei_header(), and read_mrc_header().

int EMAN::MrcIO::is_ri [private]

Definition at line 278 of file mrcio.h.

bool EMAN::MrcIO::isFEI [private]

Definition at line 276 of file mrcio.h.

Referenced by get_nimg().

int EMAN::MrcIO::mode_size [private]

Definition at line 268 of file mrcio.h.

FILE* EMAN::MrcIO::mrcfile [private]

Definition at line 267 of file mrcio.h.

Referenced by read_fei_header(), update_stat(), write_ctf(), and ~MrcIO().

MrcHeader EMAN::MrcIO::mrch [private]

Definition at line 271 of file mrcio.h.

Referenced by MrcIO(), and swap_header().

IOMode EMAN::MrcIO::rw_mode [private]

Definition at line 266 of file mrcio.h.

const char * MrcIO::SHORT_CTF_MAGIC = "!$" [static, private]

Definition at line 261 of file mrcio.h.


The documentation for this class was generated from the following files:
Generated on Mon May 2 13:29:42 2011 for EMAN2 by  doxygen 1.4.7