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

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

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

Public Attributes

 DEFINE_IMAGEIO_FUNC

Private Types

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

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
bool isFEI
int is_ri
bool is_big_endian
bool is_new_file
bool initialized
bool is_transpose
MrcHeader mrch
FeiMrcHeader feimrch

Static Private Attributes

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

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]
 

Enumeration values:
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]
 

Enumeration values:
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.

Referenced by to_mrcmode().

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(), is_ri(), 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 1235 of file mrcio.cpp.

References EMAN::ByteOrder::is_host_big_endian().

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

int MrcIO::get_mode_size int  mm  )  [static]
 

Definition at line 1128 of file mrcio.cpp.

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

Referenced by is_valid().

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

int MrcIO::get_nimg  )  [virtual]
 

Return the number of images in this image file.

Reimplemented from EMAN::ImageIO.

Definition at line 1261 of file mrcio.cpp.

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

01262 {
01263         init();
01264 
01265         if(isFEI) {
01266                 return feimrch.nz;
01267         }
01268         else {
01269                 return 1;
01270         }
01271 }

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

Definition at line 139 of file mrcio.cpp.

References data, get_mode_size(), EMAN::ByteOrder::is_data_big_endian(), EMAN::ByteOrder::is_host_big_endian(), LOGWARN, MRC_SHORT_COMPLEX, MRC_UCHAR, 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 1089 of file mrcio.cpp.

References CTF_MAGIC, EMAN::Ctf::from_string(), EMAN::ImageIO::init(), EMAN::MrcIO::MrcHeader::labels, and mrch.

Referenced by read_mrc_header().

01090 {
01091         ENTERFUNC;
01092         init();
01093         size_t n = strlen(CTF_MAGIC);
01094 
01095         int err = 1;
01096         if (strncmp(&mrch.labels[0][0], CTF_MAGIC, n) == 0) {
01097                 err = ctf.from_string(string(&mrch.labels[0][n]));
01098         }
01099         EXITFUNC;
01100         return err;
01101 }

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

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

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::MrcIO::MrcHeader::alpha, EMAN::MrcIO::MrcHeader::amax, EMAN::MrcIO::MrcHeader::amean, EMAN::MrcIO::MrcHeader::amin, EMAN::MrcIO::MrcHeader::beta, EMAN::ImageIO::check_region(), filename, EMAN::MrcIO::MrcHeader::gamma, EMAN::Region::get_ndim(), EMAN::EMUtil::get_region_dims(), ImageReadException, EMAN::ImageIO::is_complex_mode(), is_new_file, EMAN::MrcIO::MrcHeader::ispg, EMAN::MrcIO::MrcHeader::labels, EMAN::MrcIO::MrcHeader::machinestamp, EMAN::MrcIO::MrcHeader::mapc, EMAN::MrcIO::MrcHeader::mapr, EMAN::MrcIO::MrcHeader::maps, EMAN::MrcIO::MrcHeader::mode, mrch, EMAN::MrcIO::MrcHeader::mx, EMAN::MrcIO::MrcHeader::my, EMAN::MrcIO::MrcHeader::mz, EMAN::MrcIO::MrcHeader::nlabels, EMAN::MrcIO::MrcHeader::nsymbt, EMAN::MrcIO::MrcHeader::nx, EMAN::MrcIO::MrcHeader::nxstart, EMAN::MrcIO::MrcHeader::ny, EMAN::MrcIO::MrcHeader::nystart, EMAN::MrcIO::MrcHeader::nz, EMAN::MrcIO::MrcHeader::nzstart, EMAN::Region::origin, read_ctf(), EMAN::MrcIO::MrcHeader::rms, EMAN::Transform::set_trans(), to_em_datatype(), EMAN::EMAN1Ctf::to_vector(), EMAN::MrcIO::MrcHeader::xlen, EMAN::MrcIO::MrcHeader::xorigin, EMAN::MrcIO::MrcHeader::ylen, EMAN::MrcIO::MrcHeader::yorigin, EMAN::MrcIO::MrcHeader::zlen, and EMAN::MrcIO::MrcHeader::zorigin.

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

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

01256 {
01257         ByteOrder::swap_bytes((int *) &mrch, NUM_4BYTES_PRE_MAP);
01258         ByteOrder::swap_bytes((int *) &mrch.machinestamp, NUM_4BYTES_AFTER_MAP);
01259 }

int MrcIO::to_em_datatype int  mrcmode  )  [static]
 

Definition at line 1153 of file mrcio.cpp.

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

Referenced by read_fei_header(), and read_mrc_header().

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

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

Definition at line 1183 of file mrcio.cpp.

References MrcMode.

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

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

Definition at line 1273 of file mrcio.cpp.

References copy(), data, x, and y.

01274 {
01275         float * tmp = new float[xlen*ylen];
01276 
01277         for(size_t z=0; z<(size_t)zlen; ++z) {
01278                 for(size_t y=0; y<(size_t)ylen; ++y) {
01279                         for(size_t x=0; x<(size_t)xlen; ++x) {
01280                                 tmp[x*ylen+y] = data[z*xlen*ylen+y*xlen+x];
01281                         }
01282                 }
01283                 std::copy(tmp, tmp+xlen*ylen, data+z*xlen*ylen);
01284         }
01285 
01286         delete [] tmp;
01287 
01288         return 0;
01289 }

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

References EMAN::MrcIO::MrcHeader::amax, EMAN::MrcIO::MrcHeader::amean, EMAN::MrcIO::MrcHeader::amin, filename, ImageWriteException, InvalidCallException, max, min, EMAN::MrcIO::MrcHeader::mode, MRC_SHORT, mrcfile, mrch, EMAN::MrcIO::MrcHeader::nx, EMAN::MrcIO::MrcHeader::ny, EMAN::MrcIO::MrcHeader::nz, portable_fseek(), EMAN::MrcIO::MrcHeader::rms, sqrt(), and v.

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

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

References CTF_MAGIC, filename, ImageWriteException, EMAN::ImageIO::init(), EMAN::MrcIO::MrcHeader::labels, mrcfile, mrch, and EMAN::Ctf::to_string().

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


Member Data Documentation

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

Definition at line 48 of file mrcio.cpp.

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

Definition at line 282 of file mrcio.h.

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(), read_ctf(), read_mrc_header(), update_stat(), and write_ctf().

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


The documentation for this class was generated from the following files:
Generated on Tue Jul 12 13:51:33 2011 for EMAN2 by  doxygen 1.3.9.1