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)
int transpose (float *data, int nx, int ny, int nz) const

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
bool is_transpose

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                 is_transpose(false)
00055 {
00056         memset(&mrch, 0, sizeof(MrcHeader));
00057         is_big_endian = ByteOrder::is_host_big_endian();
00058 }

MrcIO::~MrcIO (  ) 

Definition at line 60 of file mrcio.cpp.

References mrcfile.

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


Member Function Documentation

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

generate the machine stamp used in MRC image format.

Definition at line 1230 of file mrcio.cpp.

References EMAN::ByteOrder::is_host_big_endian().

01231 {
01232         int stamp = 0;
01233         char *p = (char *) (&stamp);
01234 
01235         if (ByteOrder::is_host_big_endian()) {
01236                 p[0] = 0x11;
01237                 p[1] = 0x11;
01238                 p[2] = 0;
01239                 p[3] = 0;
01240         }
01241         else {
01242                 p[0] = 0x44;
01243                 p[1] = 0x41;
01244                 p[2] = 0;
01245                 p[3] = 0;
01246         }
01247         return stamp;
01248 }

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

Definition at line 1123 of file mrcio.cpp.

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

Referenced by is_valid().

01124 {
01125         MrcIO::MrcMode m = static_cast < MrcMode > (mm);
01126 
01127         int msize = 0;
01128         switch (m) {
01129         case MRC_UCHAR:
01130                 msize = sizeof(char);
01131                 break;
01132         case MRC_SHORT:
01133         case MRC_USHORT:
01134         case MRC_SHORT_COMPLEX:
01135                 msize = sizeof(short);
01136                 break;
01137         case MRC_FLOAT:
01138         case MRC_FLOAT_COMPLEX:
01139                 msize = sizeof(float);
01140                 break;
01141         default:
01142                 msize = 0;
01143         }
01144 
01145         return msize;
01146 }

int MrcIO::get_nimg (  )  [virtual]

Return the number of images in this image file.

Reimplemented from EMAN::ImageIO.

Definition at line 1256 of file mrcio.cpp.

References EMAN::ImageIO::init().

01257 {
01258         init();
01259 
01260         return 1;
01261 }

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

Definition at line 139 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().

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

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 1084 of file mrcio.cpp.

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

Referenced by read_mrc_header().

01085 {
01086         ENTERFUNC;
01087         init();
01088         size_t n = strlen(CTF_MAGIC);
01089 
01090         int err = 1;
01091         if (strncmp(&mrch.labels[0][0], CTF_MAGIC, n) == 0) {
01092                 err = ctf.from_string(string(&mrch.labels[0][n]));
01093         }
01094         EXITFUNC;
01095         return err;
01096 }

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

Definition at line 354 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::EMUtil::get_region_dims(), EMAN::MrcIO::FeiMrcExtHeader::ht, EMAN::MrcIO::FeiMrcHeader::idtype, 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.

00355 {
00356         ENTERFUNC;
00357 
00358         if(image_index < 0) {
00359                 image_index = 0;
00360         }
00361 
00362         init();
00363 
00364         check_region(area, FloatSize(feimrch.nx, feimrch.ny, feimrch.nz), is_new_file, false);
00365 
00366         int xlen = 0, ylen = 0, zlen = 0;
00367         EMUtil::get_region_dims(area, feimrch.nx, &xlen, feimrch.ny, &ylen, feimrch.nz, &zlen);
00368 
00369         dict["nx"] = xlen;
00370         dict["ny"] = ylen;
00371         dict["nz"] = zlen;
00372         dict["FEIMRC.nx"] = feimrch.nx;
00373         dict["FEIMRC.ny"] = feimrch.ny;
00374         dict["FEIMRC.nz"] = feimrch.nz;
00375 
00376         dict["datatype"] = to_em_datatype(feimrch.mode);        //=1, FEI-MRC file always use short for data type
00377 
00378         dict["FEIMRC.nxstart"] = feimrch.nxstart;
00379         dict["FEIMRC.nystart"] = feimrch.nystart;
00380         dict["FEIMRC.nzstart"] = feimrch.nzstart;
00381 
00382         dict["FEIMRC.mx"] = feimrch.mx;
00383         dict["FEIMRC.my"] = feimrch.my;
00384         dict["FEIMRC.mz"] = feimrch.mz;
00385 
00386         dict["FEIMRC.xlen"] = feimrch.xlen;
00387         dict["FEIMRC.ylen"] = feimrch.ylen;
00388         dict["FEIMRC.zlen"] = feimrch.zlen;
00389 
00390         dict["FEIMRC.alpha"] = feimrch.alpha;
00391         dict["FEIMRC.beta"] = feimrch.beta;
00392         dict["FEIMRC.gamma"] = feimrch.gamma;
00393 
00394         dict["FEIMRC.mapc"] = feimrch.mapc;
00395         dict["FEIMRC.mapr"] = feimrch.mapr;
00396         dict["FEIMRC.maps"] = feimrch.maps;
00397 
00398         dict["FEIMRC.minimum"] = feimrch.amin;
00399         dict["FEIMRC.maximum"] = feimrch.amax;
00400         dict["FEIMRC.mean"] = feimrch.amean;
00401         dict["mean"] = feimrch.amean;
00402 
00403         dict["FEIMRC.ispg"] = feimrch.ispg;
00404         dict["FEIMRC.nsymbt"] = feimrch.nsymbt;
00405 
00406         dict["apix_x"] = feimrch.xlen / feimrch.mx;
00407         dict["apix_y"] = feimrch.ylen / feimrch.my;
00408         dict["apix_z"] = feimrch.zlen / feimrch.mz;
00409 
00410         dict["FEIMRC.next"] = feimrch.next;     //offset from end of header to the first dataset
00411         dict["FEIMRC.dvid"] = feimrch.dvid;
00412         dict["FEIMRC.numintegers"] = feimrch.numintegers;
00413         dict["FEIMRC.numfloats"] = feimrch.numfloats;
00414         dict["FEIMRC.sub"] = feimrch.sub;
00415         dict["FEIMRC.zfac"] = feimrch.zfac;
00416 
00417         dict["FEIMRC.min2"] = feimrch.min2;
00418         dict["FEIMRC.max2"] = feimrch.max2;
00419         dict["FEIMRC.min3"] = feimrch.min3;
00420         dict["FEIMRC.max3"] = feimrch.max3;
00421         dict["FEIMRC.min4"] = feimrch.min4;
00422         dict["FEIMRC.max4"] = feimrch.max4;
00423 
00424         dict["FEIMRC.idtype"] = feimrch.idtype;
00425         dict["FEIMRC.lens"] = feimrch.lens;
00426         dict["FEIMRC.nd1"] = feimrch.nd1;
00427         dict["FEIMRC.nd2"] = feimrch.nd2;
00428         dict["FEIMRC.vd1"] = feimrch.vd1;
00429         dict["FEIMRC.vd2"] = feimrch.vd2;
00430 
00431         for(int i=0; i<9; i++) {        //9 tilt angles
00432                 char label[32];
00433                 sprintf(label, "MRC.tiltangles%d", i);
00434                 dict[string(label)] = feimrch.tiltangles[i];
00435         }
00436 
00437         dict["FEIMRC.zorg"] = feimrch.zorg;
00438         dict["FEIMRC.xorg"] = feimrch.xorg;
00439         dict["FEIMRC.yorg"] = feimrch.yorg;
00440 
00441         dict["FEIMRC.nlabl"] = feimrch.nlabl;
00442         for (int i = 0; i < feimrch.nlabl; i++) {
00443                 char label[32];
00444                 sprintf(label, "MRC.label%d", i);
00445                 dict[string(label)] = string(feimrch.labl[i], 80);
00446         }
00447 
00448         /* Read extended image header by specified image index*/
00449         FeiMrcExtHeader feiexth;
00450         portable_fseek(mrcfile, sizeof(FeiMrcHeader)+sizeof(FeiMrcExtHeader)*image_index, SEEK_SET);
00451         if (fread(&feiexth, sizeof(FeiMrcExtHeader), 1, mrcfile) != 1) {
00452                 throw ImageReadException(filename, "FEI MRC extended header");
00453         }
00454 
00455         dict["FEIMRC.a_tilt"] = feiexth.a_tilt;
00456         dict["FEIMRC.b_tilt"] = feiexth.b_tilt;
00457 
00458         dict["FEIMRC.x_stage"] = feiexth.x_stage;
00459         dict["FEIMRC.y_stage"] = feiexth.y_stage;
00460         dict["FEIMRC.z_stage"] = feiexth.z_stage;
00461 
00462         dict["FEIMRC.x_shift"] = feiexth.x_shift;
00463         dict["FEIMRC.y_shift"] = feiexth.y_shift;
00464 
00465         dict["FEIMRC.defocus"] = feiexth.defocus;
00466         dict["FEIMRC.exp_time"] = feiexth.exp_time;
00467         dict["FEIMRC.mean_int"] = feiexth.mean_int;
00468         dict["FEIMRC.tilt_axis"] = feiexth.tilt_axis;
00469 
00470         dict["FEIMRC.pixel_size"] = feiexth.pixel_size;
00471         dict["FEIMRC.magnification"] = feiexth.magnification;
00472         dict["FEIMRC.ht"] = feiexth.ht;
00473         dict["FEIMRC.binning"] = feiexth.binning;
00474         dict["FEIMRC.appliedDefocus"] = feiexth.appliedDefocus;
00475 
00476         //remainder 16 4-byte floats not used
00477 
00478         EXITFUNC;
00479         return 0;
00480 }

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

Definition at line 203 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, is_transpose, EMAN::Region::origin, read_ctf(), EMAN::Transform::set_trans(), to_em_datatype(), and EMAN::EMAN1Ctf::to_vector().

00204 {
00205         ENTERFUNC;
00206 
00207         //single image format, index can only be zero
00208         if(image_index < 0) {
00209                 image_index = 0;
00210         }
00211         if(image_index != 0) {
00212                 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().");
00213         }
00214 
00215         check_region(area, FloatSize(mrch.nx, mrch.ny, mrch.nz), is_new_file, false);
00216 
00217         int xlen = 0, ylen = 0, zlen = 0;
00218         EMUtil::get_region_dims(area, mrch.nx, &xlen, mrch.ny, &ylen, mrch.nz, &zlen);
00219 
00220         dict["nx"] = xlen;
00221         dict["ny"] = ylen;
00222         dict["nz"] = zlen;
00223         dict["MRC.nx"] = mrch.nx;
00224         dict["MRC.ny"] = mrch.ny;
00225         dict["MRC.nz"] = mrch.nz;
00226 
00227         dict["datatype"] = to_em_datatype(mrch.mode);
00228 
00229         dict["MRC.nxstart"] = mrch.nxstart;
00230         dict["MRC.nystart"] = mrch.nystart;
00231         dict["MRC.nzstart"] = mrch.nzstart;
00232 
00233         dict["MRC.mx"] = mrch.mx;
00234         dict["MRC.my"] = mrch.my;
00235         dict["MRC.mz"] = mrch.mz;
00236 
00237         dict["MRC.xlen"] = mrch.xlen;
00238         dict["MRC.ylen"] = mrch.ylen;
00239         dict["MRC.zlen"] = mrch.zlen;
00240 
00241         dict["MRC.alpha"] = mrch.alpha;
00242         dict["MRC.beta"] = mrch.beta;
00243         dict["MRC.gamma"] = mrch.gamma;
00244 
00245         dict["MRC.mapc"] = mrch.mapc;
00246         dict["MRC.mapr"] = mrch.mapr;
00247         dict["MRC.maps"] = mrch.maps;
00248 
00249         dict["MRC.minimum"] = mrch.amin;
00250         dict["MRC.maximum"] = mrch.amax;
00251         dict["MRC.mean"] = mrch.amean;
00252         dict["mean"] = mrch.amean;
00253 
00254         dict["MRC.ispg"] = mrch.ispg;
00255         dict["MRC.nsymbt"] = mrch.nsymbt;
00256 
00257         float apx = mrch.xlen / mrch.mx;
00258         float apy = mrch.ylen / mrch.my;
00259         float apz = mrch.zlen / mrch.mz;
00260         if(apx>1000 || apx<0.01) {
00261                 dict["apix_x"] = 1.0f;
00262         }
00263         else {
00264                 dict["apix_x"] = apx;
00265         }
00266         if(apy>1000 || apy<0.01) {
00267                 dict["apix_y"] = 1.0f;
00268         }
00269         else {
00270                 dict["apix_y"] = apy;
00271         }
00272         if(apz>1000 || apz<0.01) {
00273                 dict["apix_z"] = 1.0f;
00274         }
00275         else {
00276                 dict["apix_z"] = apz;
00277         }
00278 
00279         if (area) {
00280                 dict["origin_x"] = mrch.xorigin + mrch.xlen * area->origin[0];
00281                 dict["origin_y"] = mrch.yorigin + mrch.xlen * area->origin[1];
00282 
00283                 if (area->get_ndim() == 3 && mrch.nz > 1) {
00284                         dict["origin_z"] = mrch.zorigin + mrch.xlen * area->origin[2];
00285                 }
00286                 else {
00287                         dict["origin_z"] = mrch.zorigin;
00288                 }
00289         }
00290         else {
00291                 dict["origin_x"] = mrch.xorigin;
00292                 dict["origin_y"] = mrch.yorigin;
00293                 dict["origin_z"] = mrch.zorigin;
00294         }
00295 
00296         if (is_complex_mode()) {
00297                 dict["is_complex"] = 1;
00298                 dict["is_complex_ri"] = 1;
00299         }
00300 
00301         dict["MRC.machinestamp"] = mrch.machinestamp;
00302 
00303         dict["MRC.rms"] = mrch.rms;
00304         dict["sigma"] = mrch.rms;
00305         dict["MRC.nlabels"] = mrch.nlabels;
00306         for (int i = 0; i < mrch.nlabels; i++) {
00307                 char label[32];
00308                 sprintf(label, "MRC.label%d", i);
00309                 dict[string(label)] = string(mrch.labels[i],80);
00310         }
00311 
00312         EMAN1Ctf ctf_;
00313         if(read_ctf(ctf_) == 0) {
00314                 vector<float> vctf = ctf_.to_vector();
00315                 dict["ctf"] = vctf;
00316         }
00317 
00318         if(is_transpose) {
00319                 dict["nx"] = ylen;
00320                 dict["ny"] = xlen;
00321                 dict["MRC.nx"] = mrch.ny;
00322                 dict["MRC.ny"] = mrch.nx;
00323                 dict["MRC.mx"] = mrch.my;
00324                 dict["MRC.my"] = mrch.mx;
00325                 dict["apix_x"] = mrch.ylen / mrch.my;
00326                 dict["apix_y"] = mrch.xlen / mrch.mx;
00327                 dict["origin_x"] = mrch.yorigin;
00328                 dict["origin_y"] = mrch.xorigin;
00329                 dict["MRC.nxstart"] = mrch.nystart;
00330                 dict["MRC.nystart"] = mrch.nxstart;
00331         }
00332 
00333         Transform * trans = new Transform();
00334         if(is_transpose) {
00335                 trans->set_trans(mrch.nystart, mrch.nxstart, mrch.nzstart);
00336         }
00337         else {
00338                 trans->set_trans(mrch.nxstart, mrch.nystart, mrch.nzstart);
00339         }
00340         
00341         if(zlen<=1) {
00342                 dict["xform.projection"] = trans;
00343         }
00344         else {
00345                 dict["xform.align3d"] = trans;
00346         }
00347 
00348         if(trans) {delete trans; trans=0;}
00349 
00350         EXITFUNC;
00351         return 0;
00352 }

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

Definition at line 1250 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 1148 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().

01149 {
01150         EMUtil::EMDataType e = EMUtil::EM_UNKNOWN;
01151 
01152         switch (m) {
01153         case MRC_UCHAR:
01154                 e = EMUtil::EM_UCHAR;
01155                 break;
01156         case MRC_SHORT:
01157                 e = EMUtil::EM_SHORT;
01158                 break;
01159         case MRC_USHORT:
01160                 e = EMUtil::EM_USHORT;
01161                 break;
01162         case MRC_SHORT_COMPLEX:
01163                 e = EMUtil::EM_SHORT_COMPLEX;
01164                 break;
01165         case MRC_FLOAT:
01166                 e = EMUtil::EM_FLOAT;
01167                 break;
01168         case MRC_FLOAT_COMPLEX:
01169                 e = EMUtil::EM_FLOAT_COMPLEX;
01170                 break;
01171         default:
01172                 e = EMUtil::EM_UNKNOWN;
01173         }
01174         return e;
01175 }

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

Definition at line 1178 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.

01179 {
01180         MrcMode m = MRC_UNKNOWN;
01181         EMUtil::EMDataType em_type = static_cast < EMUtil::EMDataType > (e);
01182 
01183         switch (em_type) {
01184         case EMUtil::EM_UCHAR:
01185                 m = MRC_UCHAR;
01186                 break;
01187         case EMUtil::EM_USHORT:
01188                 if (is_complex) {
01189                         m = MRC_SHORT_COMPLEX;
01190                 }
01191                 else {
01192                         m = MRC_USHORT;
01193                 }
01194                 break;
01195         case EMUtil::EM_SHORT:
01196                 if (is_complex) {
01197                         m = MRC_SHORT_COMPLEX;
01198                 }
01199                 else {
01200                         m = MRC_SHORT;
01201                 }
01202                 break;
01203         case EMUtil::EM_SHORT_COMPLEX:
01204         case EMUtil::EM_USHORT_COMPLEX:
01205                 m = MRC_SHORT_COMPLEX;
01206                 break;
01207         case EMUtil::EM_CHAR:
01208         case EMUtil::EM_INT:
01209         case EMUtil::EM_UINT:
01210         case EMUtil::EM_FLOAT:
01211                 if (is_complex) {
01212                         m = MRC_FLOAT_COMPLEX;
01213                 }
01214                 else {
01215                         m = MRC_FLOAT;
01216                 }
01217                 break;
01218         case EMUtil::EM_FLOAT_COMPLEX:
01219                 m = MRC_FLOAT_COMPLEX;
01220                 break;
01221         default:
01222                 m = MRC_FLOAT;
01223         }
01224 
01225         return m;
01226 }

int MrcIO::transpose ( float *  data,
int  nx,
int  ny,
int  nz 
) const [private]

Definition at line 1263 of file mrcio.cpp.

References copy(), x, and y.

01264 {
01265         float * tmp = new float[xlen*ylen];
01266 
01267         for(size_t z=0; z<(size_t)zlen; ++z) {
01268                 for(size_t y=0; y<(size_t)ylen; ++y) {
01269                         for(size_t x=0; x<(size_t)xlen; ++x) {
01270                                 tmp[x*ylen+y] = data[z*xlen*ylen+y*xlen+x];
01271                         }
01272                 }
01273                 std::copy(tmp, tmp+xlen*ylen, data+z*xlen*ylen);
01274         }
01275 
01276         delete [] tmp;
01277 
01278         return 0;
01279 }

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 961 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.

00962 {
00963         size_t size =  mrch.nx * mrch.ny * mrch.nz;
00964         float v = 0.0f; //variable to hold pixel value
00965         double sum = 0.0;
00966         double square_sum = 0.0;
00967         double mean = 0.0;
00968         float min, max;
00969         
00970         unsigned char * cdata = 0;
00971         short * sdata = 0;
00972         unsigned short * usdata = 0;
00973         
00974         if (mrch.mode == MRC_UCHAR) {
00975                 max = 0.0f;
00976                 min = UCHAR_MAX;
00977                 cdata = (unsigned char *)data;
00978                 
00979                 for (size_t i = 0; i < size; ++i) {
00980                         v = (float)(cdata[i]);
00981 #ifdef _WIN32
00982                         max = _cpp_max(max,v);
00983                         min = _cpp_min(min,v);
00984 #else
00985                         max=std::max<float>(max,v);
00986                         min=std::min<float>(min,v);
00987 #endif  //_WIN32
00988                         
00989                         sum += v;
00990                         square_sum += v * v;
00991                 }
00992         }
00993         else if (mrch.mode == MRC_SHORT || mrch.mode == MRC_SHORT_COMPLEX) {
00994                 max = (float)SHRT_MIN;
00995                 min = (float)SHRT_MAX;
00996                 sdata = (short *)data;
00997                 
00998                 for (size_t i = 0; i < size; ++i) {
00999                         v = (float)(sdata[i]);
01000 #ifdef _WIN32
01001                         max = _cpp_max(max,v);
01002                         min = _cpp_min(min,v);
01003 #else
01004                         max=std::max<float>(max,v);
01005                         min=std::min<float>(min,v);
01006 #endif  //_WIN32
01007                         
01008                         sum += v;
01009                         square_sum += v * v;
01010                 }
01011         }
01012         else if (mrch.mode == MRC_USHORT) {
01013                 max = 0.0f;
01014                 min = (float)USHRT_MAX;
01015                 usdata = (unsigned short*)data;
01016                 
01017                 for (size_t i = 0; i < size; ++i) {
01018                         v = (float)(usdata[i]);
01019 #ifdef _WIN32
01020                         max = _cpp_max(max,v);
01021                         min = _cpp_min(min,v);
01022 #else
01023                         max=std::max<float>(max,v);
01024                         min=std::min<float>(min,v);
01025 #endif  //_WIN32
01026                         
01027                         sum += v;
01028                         square_sum += v * v;
01029                 }
01030         }
01031         else {
01032                 throw InvalidCallException("This function is used to write 8bit/16bit mrc file only.");
01033         }
01034         
01035         mean = sum/size;
01036 #ifdef _WIN32
01037         float sigma = (float)std::sqrt( _cpp_max(0.0,(square_sum - sum*sum / size)/(size-1)));
01038 #else
01039         float sigma = (float)std::sqrt(std::max<float>(0.0,(square_sum - sum*sum / size)/(size-1)));
01040 #endif  //_WIN32
01041 
01042         /*change mrch.amin/amax/amean.rms here*/
01043         mrch.amin = min;
01044         mrch.amax = max;
01045         mrch.amean = (float)mean;
01046         mrch.rms = sigma;
01047         
01048         MrcHeader mrch2 = mrch;
01049 
01050 //endian issue, can't get use_host_endian argument
01051 //      bool opposite_endian = false;
01052 
01053 //      if (!is_new_file) {
01054 //              if (is_big_endian != ByteOrder::is_host_big_endian()) {
01055 //                      opposite_endian = true;
01056 //              }
01057 //
01058 //              portable_fseek(mrcfile, 0, SEEK_SET);
01059 //      }
01060 //      
01061 //      if (opposite_endian || !use_host_endian) {
01062 //              swap_header(mrch2);
01063 //      }
01064 
01065         portable_fseek(mrcfile, 0, SEEK_SET);
01066         
01067         if (fwrite(&mrch2, sizeof(MrcHeader), 1, mrcfile) != 1) {
01068                 throw ImageWriteException(filename, "MRC header");
01069         }
01070         
01071         portable_fseek(mrcfile, sizeof(MrcHeader), SEEK_SET);
01072 }

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 1098 of file mrcio.cpp.

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

01099 {
01100         ENTERFUNC;
01101         init();
01102 
01103         string ctf_str = ctf.to_string();
01104 #ifdef _WIN32
01105         _snprintf(&mrch.labels[0][0],80, "%s%s", CTF_MAGIC, ctf_str.c_str());
01106 #else
01107         snprintf(&mrch.labels[0][0],80, "%s%s", CTF_MAGIC, ctf_str.c_str());
01108 #endif  //_WIN32
01109         rewind(mrcfile);
01110 
01111         if (fwrite(&mrch, sizeof(MrcHeader), 1, mrcfile) != 1) {
01112                 throw ImageWriteException(filename, "write CTF info to header failed");
01113         }
01114         EXITFUNC;
01115 }


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 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::is_transpose [private]

Definition at line 282 of file mrcio.h.

Referenced by read_mrc_header().

bool EMAN::MrcIO::isFEI [private]

Definition at line 276 of file mrcio.h.

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 Thu Nov 17 12:45:41 2011 for EMAN2 by  doxygen 1.4.7