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

References EMAN::ByteOrder::is_host_big_endian().

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

int MrcIO::get_mode_size int  mm  )  [static]
 

Definition at line 1126 of file mrcio.cpp.

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

Referenced by is_valid().

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

int MrcIO::get_nimg  )  [virtual]
 

Return the number of images in this image file.

Reimplemented from EMAN::ImageIO.

Definition at line 1259 of file mrcio.cpp.

References EMAN::ImageIO::init().

01260 {
01261         init();
01262 
01263         return 1;
01264 }

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 1087 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().

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

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

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

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

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_rotation(), 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                 trans->set_rotation(Dict("type", "imagic", "alpha", mrch.alpha, "beta", mrch.beta, "gamma", mrch.gamma));
00337         }
00338         else {
00339                 trans->set_trans(mrch.nxstart, mrch.nystart, mrch.nzstart);
00340                 trans->set_rotation(Dict("type", "imagic", "alpha", mrch.alpha, "beta", mrch.beta, "gamma", mrch.gamma));
00341         }
00342         
00343         if(zlen<=1) {
00344                 dict["xform.projection"] = trans;
00345         }
00346         else {
00347                 dict["xform.align3d"] = trans;
00348         }
00349 
00350         if(trans) {delete trans; trans=0;}
00351 
00352         EXITFUNC;
00353         return 0;
00354 }

void MrcIO::swap_header MrcHeader mrch  )  [private]
 

Definition at line 1253 of file mrcio.cpp.

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

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

int MrcIO::to_em_datatype int  mrcmode  )  [static]
 

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

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

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

Definition at line 1181 of file mrcio.cpp.

References MrcMode.

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

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

Definition at line 1266 of file mrcio.cpp.

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

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

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

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

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

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

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


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 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 Jun 11 13:48:11 2013 for EMAN2 by  doxygen 1.3.9.1