#include <mrcio.h>
Inheritance diagram for EMAN::MrcIO:


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) |
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 |
| MrcHeader | mrch |
| FeiMrcHeader | feimrch |
Static Private Attributes | |
| const char * | CTF_MAGIC = "!-" |
| const char * | SHORT_CTF_MAGIC = "!$" |
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.
|
|
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 };
|
|
|
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 };
|
|
||||||||||||
|
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 { 00055 memset(&mrch, 0, sizeof(MrcHeader)); 00056 is_big_endian = ByteOrder::is_host_big_endian(); 00057 }
|
|
|
Definition at line 59 of file mrcio.cpp. References mrcfile. 00060 {
00061 if (mrcfile) {
00062 fclose(mrcfile);
00063 mrcfile = 0;
00064 }
00065 }
|
|
|
generate the machine stamp used in MRC image format.
Definition at line 1174 of file mrcio.cpp. References EMAN::ByteOrder::is_host_big_endian(). 01175 {
01176 int stamp = 0;
01177 char *p = (char *) (&stamp);
01178
01179 if (ByteOrder::is_host_big_endian()) {
01180 p[0] = 0x11;
01181 p[1] = 0x11;
01182 p[2] = 0;
01183 p[3] = 0;
01184 }
01185 else {
01186 p[0] = 0x44;
01187 p[1] = 0x41;
01188 p[2] = 0;
01189 p[3] = 0;
01190 }
01191 return stamp;
01192 }
|
|
|
Definition at line 1067 of file mrcio.cpp. References MRC_FLOAT, MRC_FLOAT_COMPLEX, MRC_SHORT, MRC_SHORT_COMPLEX, MRC_UCHAR, and MRC_USHORT. Referenced by is_valid(). 01068 {
01069 MrcIO::MrcMode m = static_cast < MrcMode > (mm);
01070
01071 int msize = 0;
01072 switch (m) {
01073 case MRC_UCHAR:
01074 msize = sizeof(char);
01075 break;
01076 case MRC_SHORT:
01077 case MRC_USHORT:
01078 case MRC_SHORT_COMPLEX:
01079 msize = sizeof(short);
01080 break;
01081 case MRC_FLOAT:
01082 case MRC_FLOAT_COMPLEX:
01083 msize = sizeof(float);
01084 break;
01085 default:
01086 msize = 0;
01087 }
01088
01089 return msize;
01090 }
|
|
|
Return the number of images in this image file.
Reimplemented from EMAN::ImageIO. Definition at line 1200 of file mrcio.cpp. References feimrch, EMAN::ImageIO::init(), and EMAN::MrcIO::FeiMrcHeader::nz. 01201 {
01202 init();
01203
01204 if(isFEI) {
01205 return feimrch.nz;
01206 }
01207 else {
01208 return 1;
01209 }
01210 }
|
|
||||||||||||
|
Definition at line 134 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(). 00135 {
00136 ENTERFUNC;
00137
00138 if (!first_block) {
00139 return false;
00140 }
00141
00142 const int *data = static_cast < const int *>(first_block);
00143 int nx = data[0];
00144 int ny = data[1];
00145 int nz = data[2];
00146 int mrcmode = data[3];
00147 int nsymbt = data[23]; //this field specify the extra bytes for symmetry information
00148
00149 bool data_big_endian = ByteOrder::is_data_big_endian(&nz);
00150
00151 if (data_big_endian != ByteOrder::is_host_big_endian()) {
00152 ByteOrder::swap_bytes(&nx);
00153 ByteOrder::swap_bytes(&ny);
00154 ByteOrder::swap_bytes(&nz);
00155 ByteOrder::swap_bytes(&mrcmode);
00156 ByteOrder::swap_bytes(&nsymbt);
00157 }
00158
00159 if (mrcmode == MRC_SHORT_COMPLEX || mrcmode == MRC_FLOAT_COMPLEX) {
00160 nx *= 2;
00161 }
00162
00163 const int max_dim = 1 << 20;
00164
00165 if ((mrcmode >= MRC_UCHAR && mrcmode < MRC_UNKNOWN) &&
00166 (nx > 1 && nx < max_dim) && (ny > 0 && ny < max_dim) && (nz > 0 && nz < max_dim)) {
00167 //#ifndef SPIDERMRC // Spider MRC files don't satisfy the following test
00168 if (file_size > 0) {
00169 off_t file_size1 = (off_t)nx * (off_t)ny * (off_t)nz * (off_t)get_mode_size(mrcmode) + (off_t)sizeof(MrcHeader) + nsymbt;
00170 if (file_size == file_size1) {
00171 return true;
00172 }
00173 // return false;
00174 LOGWARN("image size check fails, still try to read it..."); //when size doesn't match, print error message instead of make it fail
00175 }
00176 else {
00177 return true;
00178 }
00179 //#endif // SPIDERMRC
00180 return true;
00181 }
00182 EXITFUNC;
00183 return false;
00184 }
|
|
||||||||||||
|
Read CTF data from this image.
Reimplemented from EMAN::ImageIO. Definition at line 1032 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(). 01033 {
01034 ENTERFUNC;
01035 init();
01036 size_t n = strlen(CTF_MAGIC);
01037
01038 int err = 1;
01039 if (strncmp(&mrch.labels[0][0], CTF_MAGIC, n) == 0) {
01040 err = ctf.from_string(string(&mrch.labels[0][n]));
01041 }
01042 EXITFUNC;
01043 return err;
01044 }
|
|
||||||||||||||||||||
|
Definition at line 317 of file mrcio.cpp. References EMAN::MrcIO::FeiMrcExtHeader::a_tilt, EMAN::MrcIO::FeiMrcHeader::alpha, EMAN::MrcIO::FeiMrcHeader::amax, EMAN::MrcIO::FeiMrcHeader::amean, EMAN::MrcIO::FeiMrcHeader::amin, EMAN::MrcIO::FeiMrcExtHeader::appliedDefocus, EMAN::MrcIO::FeiMrcExtHeader::b_tilt, EMAN::MrcIO::FeiMrcHeader::beta, EMAN::MrcIO::FeiMrcExtHeader::binning, EMAN::ImageIO::check_region(), EMAN::MrcIO::FeiMrcExtHeader::defocus, EMAN::MrcIO::FeiMrcHeader::dvid, EMAN::MrcIO::FeiMrcExtHeader::exp_time, feimrch, filename, EMAN::MrcIO::FeiMrcHeader::gamma, EMAN::Region::get_depth(), EMAN::EMUtil::get_region_dims(), EMAN::MrcIO::FeiMrcExtHeader::ht, EMAN::MrcIO::FeiMrcHeader::idtype, ImageDimensionException, ImageReadException, EMAN::ImageIO::init(), is_new_file, EMAN::MrcIO::FeiMrcHeader::ispg, EMAN::MrcIO::FeiMrcHeader::labl, EMAN::MrcIO::FeiMrcHeader::lens, EMAN::MrcIO::FeiMrcExtHeader::magnification, EMAN::MrcIO::FeiMrcHeader::mapc, EMAN::MrcIO::FeiMrcHeader::mapr, EMAN::MrcIO::FeiMrcHeader::maps, EMAN::MrcIO::FeiMrcHeader::max2, EMAN::MrcIO::FeiMrcHeader::max3, EMAN::MrcIO::FeiMrcHeader::max4, EMAN::MrcIO::FeiMrcExtHeader::mean_int, EMAN::MrcIO::FeiMrcHeader::min2, EMAN::MrcIO::FeiMrcHeader::min3, EMAN::MrcIO::FeiMrcHeader::min4, EMAN::MrcIO::FeiMrcHeader::mode, mrcfile, EMAN::MrcIO::FeiMrcHeader::mx, EMAN::MrcIO::FeiMrcHeader::my, EMAN::MrcIO::FeiMrcHeader::mz, EMAN::MrcIO::FeiMrcHeader::nd1, EMAN::MrcIO::FeiMrcHeader::nd2, EMAN::MrcIO::FeiMrcHeader::next, EMAN::MrcIO::FeiMrcHeader::nlabl, EMAN::MrcIO::FeiMrcHeader::nsymbt, EMAN::MrcIO::FeiMrcHeader::numfloats, EMAN::MrcIO::FeiMrcHeader::numintegers, EMAN::MrcIO::FeiMrcHeader::nx, EMAN::MrcIO::FeiMrcHeader::nxstart, EMAN::MrcIO::FeiMrcHeader::ny, EMAN::MrcIO::FeiMrcHeader::nystart, EMAN::MrcIO::FeiMrcHeader::nz, EMAN::MrcIO::FeiMrcHeader::nzstart, EMAN::MrcIO::FeiMrcExtHeader::pixel_size, portable_fseek(), EMAN::MrcIO::FeiMrcHeader::sub, EMAN::MrcIO::FeiMrcExtHeader::tilt_axis, EMAN::MrcIO::FeiMrcHeader::tiltangles, to_em_datatype(), EMAN::MrcIO::FeiMrcHeader::vd1, EMAN::MrcIO::FeiMrcHeader::vd2, EMAN::MrcIO::FeiMrcExtHeader::x_shift, EMAN::MrcIO::FeiMrcExtHeader::x_stage, EMAN::MrcIO::FeiMrcHeader::xlen, EMAN::MrcIO::FeiMrcHeader::xorg, EMAN::MrcIO::FeiMrcExtHeader::y_shift, EMAN::MrcIO::FeiMrcExtHeader::y_stage, EMAN::MrcIO::FeiMrcHeader::ylen, EMAN::MrcIO::FeiMrcHeader::yorg, EMAN::MrcIO::FeiMrcExtHeader::z_stage, EMAN::MrcIO::FeiMrcHeader::zfac, EMAN::MrcIO::FeiMrcHeader::zlen, and EMAN::MrcIO::FeiMrcHeader::zorg. 00318 {
00319 ENTERFUNC;
00320
00321 if(image_index < 0) {
00322 image_index = 0;
00323 }
00324
00325 if(area && area->get_depth() > 1) {
00326 throw ImageDimensionException("FEI MRC image is 2D tile series, only 2D regional reading accepted.");
00327 }
00328
00329 init();
00330
00331 check_region(area, FloatSize(feimrch.nx, feimrch.ny, feimrch.nz), is_new_file,false);
00332
00333 int xlen = 0, ylen = 0, zlen = 0;
00334 EMUtil::get_region_dims(area, feimrch.nx, &xlen, feimrch.ny, &ylen, feimrch.nz, &zlen);
00335
00336 dict["nx"] = xlen;
00337 dict["ny"] = ylen;
00338 dict["nz"] = 1; //only read one 2D image from a tilt series
00339 dict["FEIMRC.nx"] = feimrch.nx;
00340 dict["FEIMRC.ny"] = feimrch.ny;
00341 dict["FEIMRC.nz"] = feimrch.nz;
00342
00343 dict["datatype"] = to_em_datatype(feimrch.mode); //=1, FEI-MRC file always use short for data type
00344
00345 dict["FEIMRC.nxstart"] = feimrch.nxstart;
00346 dict["FEIMRC.nystart"] = feimrch.nystart;
00347 dict["FEIMRC.nzstart"] = feimrch.nzstart;
00348
00349 dict["FEIMRC.mx"] = feimrch.mx;
00350 dict["FEIMRC.my"] = feimrch.my;
00351 dict["FEIMRC.mz"] = feimrch.mz;
00352
00353 dict["FEIMRC.xlen"] = feimrch.xlen;
00354 dict["FEIMRC.ylen"] = feimrch.ylen;
00355 dict["FEIMRC.zlen"] = feimrch.zlen;
00356
00357 dict["FEIMRC.alpha"] = feimrch.alpha;
00358 dict["FEIMRC.beta"] = feimrch.beta;
00359 dict["FEIMRC.gamma"] = feimrch.gamma;
00360
00361 dict["FEIMRC.mapc"] = feimrch.mapc;
00362 dict["FEIMRC.mapr"] = feimrch.mapr;
00363 dict["FEIMRC.maps"] = feimrch.maps;
00364
00365 dict["FEIMRC.minimum"] = feimrch.amin;
00366 dict["FEIMRC.maximum"] = feimrch.amax;
00367 dict["FEIMRC.mean"] = feimrch.amean;
00368 dict["mean"] = feimrch.amean;
00369
00370 dict["FEIMRC.ispg"] = feimrch.ispg;
00371 dict["FEIMRC.nsymbt"] = feimrch.nsymbt;
00372
00373 dict["apix_x"] = feimrch.xlen / feimrch.mx;
00374 dict["apix_y"] = feimrch.ylen / feimrch.my;
00375 dict["apix_z"] = feimrch.zlen / feimrch.mz;
00376
00377 dict["FEIMRC.next"] = feimrch.next; //offset from end of header to the first dataset
00378 dict["FEIMRC.dvid"] = feimrch.dvid;
00379 dict["FEIMRC.numintegers"] = feimrch.numintegers;
00380 dict["FEIMRC.numfloats"] = feimrch.numfloats;
00381 dict["FEIMRC.sub"] = feimrch.sub;
00382 dict["FEIMRC.zfac"] = feimrch.zfac;
00383
00384 dict["FEIMRC.min2"] = feimrch.min2;
00385 dict["FEIMRC.max2"] = feimrch.max2;
00386 dict["FEIMRC.min3"] = feimrch.min3;
00387 dict["FEIMRC.max3"] = feimrch.max3;
00388 dict["FEIMRC.min4"] = feimrch.min4;
00389 dict["FEIMRC.max4"] = feimrch.max4;
00390
00391 dict["FEIMRC.idtype"] = feimrch.idtype;
00392 dict["FEIMRC.lens"] = feimrch.lens;
00393 dict["FEIMRC.nd1"] = feimrch.nd1;
00394 dict["FEIMRC.nd2"] = feimrch.nd2;
00395 dict["FEIMRC.vd1"] = feimrch.vd1;
00396 dict["FEIMRC.vd2"] = feimrch.vd2;
00397
00398 for(int i=0; i<9; i++) { //9 tilt angles
00399 char label[32];
00400 sprintf(label, "MRC.tiltangles%d", i);
00401 dict[string(label)] = feimrch.tiltangles[i];
00402 }
00403
00404 dict["FEIMRC.zorg"] = feimrch.zorg;
00405 dict["FEIMRC.xorg"] = feimrch.xorg;
00406 dict["FEIMRC.yorg"] = feimrch.yorg;
00407
00408 dict["FEIMRC.nlabl"] = feimrch.nlabl;
00409 for (int i = 0; i < feimrch.nlabl; i++) {
00410 char label[32];
00411 sprintf(label, "MRC.label%d", i);
00412 dict[string(label)] = string(feimrch.labl[i], 80);
00413 }
00414
00415 /* Read extended image header by specified image index*/
00416 FeiMrcExtHeader feiexth;
00417 portable_fseek(mrcfile, sizeof(FeiMrcHeader)+sizeof(FeiMrcExtHeader)*image_index, SEEK_SET);
00418 if (fread(&feiexth, sizeof(FeiMrcExtHeader), 1, mrcfile) != 1) {
00419 throw ImageReadException(filename, "FEI MRC extended header");
00420 }
00421
00422 dict["FEIMRC.a_tilt"] = feiexth.a_tilt;
00423 dict["FEIMRC.b_tilt"] = feiexth.b_tilt;
00424
00425 dict["FEIMRC.x_stage"] = feiexth.x_stage;
00426 dict["FEIMRC.y_stage"] = feiexth.y_stage;
00427 dict["FEIMRC.z_stage"] = feiexth.z_stage;
00428
00429 dict["FEIMRC.x_shift"] = feiexth.x_shift;
00430 dict["FEIMRC.y_shift"] = feiexth.y_shift;
00431
00432 dict["FEIMRC.defocus"] = feiexth.defocus;
00433 dict["FEIMRC.exp_time"] = feiexth.exp_time;
00434 dict["FEIMRC.mean_int"] = feiexth.mean_int;
00435 dict["FEIMRC.tilt_axis"] = feiexth.tilt_axis;
00436
00437 dict["FEIMRC.pixel_size"] = feiexth.pixel_size;
00438 dict["FEIMRC.magnification"] = feiexth.magnification;
00439 dict["FEIMRC.ht"] = feiexth.ht;
00440 dict["FEIMRC.binning"] = feiexth.binning;
00441 dict["FEIMRC.appliedDefocus"] = feiexth.appliedDefocus;
00442
00443 //remainder 16 4-byte floats not used
00444
00445 EXITFUNC;
00446 return 0;
00447 }
|
|
||||||||||||||||||||
|
Definition at line 198 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, EMAN::Dict::put(), read_ctf(), EMAN::MrcIO::MrcHeader::rms, 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. 00199 {
00200 ENTERFUNC;
00201
00202 //single image format, index can only be zero
00203 if(image_index < 0) {
00204 image_index = 0;
00205 }
00206 if(image_index != 0) {
00207 throw ImageReadException(filename, "no stack allowed for MRC image. For take 2D slice out of 3D image, read the 3D image first, then use get_clip().");
00208 }
00209
00210 check_region(area, FloatSize(mrch.nx, mrch.ny, mrch.nz), is_new_file,false);
00211
00212 int xlen = 0, ylen = 0, zlen = 0;
00213 EMUtil::get_region_dims(area, mrch.nx, &xlen, mrch.ny, &ylen, mrch.nz, &zlen);
00214
00215 dict["nx"] = xlen;
00216 dict["ny"] = ylen;
00217 dict["nz"] = zlen;
00218 dict["MRC.nx"] = mrch.nx;
00219 dict["MRC.ny"] = mrch.ny;
00220 dict["MRC.nz"] = mrch.nz;
00221
00222 dict["datatype"] = to_em_datatype(mrch.mode);
00223
00224 dict["MRC.nxstart"] = mrch.nxstart;
00225 dict["MRC.nystart"] = mrch.nystart;
00226 dict["MRC.nzstart"] = mrch.nzstart;
00227
00228 dict["MRC.mx"] = mrch.mx;
00229 dict["MRC.my"] = mrch.my;
00230 dict["MRC.mz"] = mrch.mz;
00231
00232 dict["MRC.xlen"] = mrch.xlen;
00233 dict["MRC.ylen"] = mrch.ylen;
00234 dict["MRC.zlen"] = mrch.zlen;
00235
00236 dict["MRC.alpha"] = mrch.alpha;
00237 dict["MRC.beta"] = mrch.beta;
00238 dict["MRC.gamma"] = mrch.gamma;
00239
00240 dict["MRC.mapc"] = mrch.mapc;
00241 dict["MRC.mapr"] = mrch.mapr;
00242 dict["MRC.maps"] = mrch.maps;
00243
00244 dict["MRC.minimum"] = mrch.amin;
00245 dict["MRC.maximum"] = mrch.amax;
00246 dict["MRC.mean"] = mrch.amean;
00247 dict["mean"] = mrch.amean;
00248
00249 dict["MRC.ispg"] = mrch.ispg;
00250 dict["MRC.nsymbt"] = mrch.nsymbt;
00251
00252 dict["apix_x"] = mrch.xlen / mrch.mx;
00253 dict["apix_y"] = mrch.ylen / mrch.my;
00254 dict["apix_z"] = mrch.zlen / mrch.mz;
00255
00256 if (area) {
00257 dict["origin_x"] = mrch.xorigin + mrch.xlen * area->origin[0];
00258 dict["origin_y"] = mrch.yorigin + mrch.xlen * area->origin[1];
00259
00260 if (area->get_ndim() == 3 && mrch.nz > 1) {
00261 dict["origin_z"] = mrch.zorigin + mrch.xlen * area->origin[2];
00262 }
00263 else {
00264 dict["origin_z"] = mrch.zorigin;
00265 }
00266 }
00267 else {
00268 dict["origin_x"] = mrch.xorigin;
00269 dict["origin_y"] = mrch.yorigin;
00270 dict["origin_z"] = mrch.zorigin;
00271 }
00272
00273 if (is_complex_mode()) {
00274 dict["is_complex"] = 1;
00275 dict["is_complex_ri"] = 1;
00276 }
00277
00278 dict["MRC.machinestamp"] = mrch.machinestamp;
00279
00280 dict["MRC.rms"] = mrch.rms;
00281 dict["sigma"] = mrch.rms;
00282 dict["MRC.nlabels"] = mrch.nlabels;
00283 for (int i = 0; i < mrch.nlabels; i++) {
00284 char label[32];
00285 sprintf(label, "MRC.label%d", i);
00286 dict[string(label)] = string(mrch.labels[i],80);
00287 }
00288
00289 EMAN1Ctf ctf_;
00290 if(read_ctf(ctf_) == 0) {
00291 vector<float> vctf = ctf_.to_vector();
00292 dict["ctf"] = vctf;
00293 }
00294
00295 Dict dic;
00296 dic.put("type", "imagic");
00297 dic.put("alpha", mrch.alpha);
00298 dic.put("beta", mrch.beta);
00299 dic.put("gamma", mrch.gamma);
00300 dic.put("tx", mrch.xorigin);
00301 dic.put("ty", mrch.yorigin);
00302 dic.put("tz", mrch.zorigin);
00303 Transform * trans = new Transform(dic);
00304 if(zlen<=1) {
00305 dict["xform.projection"] = trans;
00306 }
00307 else {
00308 dict["xform.align3d"] = trans;
00309 }
00310
00311 if(trans) {delete trans; trans=0;}
00312
00313 EXITFUNC;
00314 return 0;
00315 }
|
|
|
Definition at line 1194 of file mrcio.cpp. References NUM_4BYTES_AFTER_MAP, NUM_4BYTES_PRE_MAP, and EMAN::ByteOrder::swap_bytes(). 01195 {
01196 ByteOrder::swap_bytes((int *) &mrch, NUM_4BYTES_PRE_MAP);
01197 ByteOrder::swap_bytes((int *) &mrch.machinestamp, NUM_4BYTES_AFTER_MAP);
01198 }
|
|
|
Definition at line 1092 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(). 01093 {
01094 EMUtil::EMDataType e = EMUtil::EM_UNKNOWN;
01095
01096 switch (m) {
01097 case MRC_UCHAR:
01098 e = EMUtil::EM_UCHAR;
01099 break;
01100 case MRC_SHORT:
01101 e = EMUtil::EM_SHORT;
01102 break;
01103 case MRC_USHORT:
01104 e = EMUtil::EM_USHORT;
01105 break;
01106 case MRC_SHORT_COMPLEX:
01107 e = EMUtil::EM_SHORT_COMPLEX;
01108 break;
01109 case MRC_FLOAT:
01110 e = EMUtil::EM_FLOAT;
01111 break;
01112 case MRC_FLOAT_COMPLEX:
01113 e = EMUtil::EM_FLOAT_COMPLEX;
01114 break;
01115 default:
01116 e = EMUtil::EM_UNKNOWN;
01117 }
01118 return e;
01119 }
|
|
||||||||||||
|
Definition at line 1122 of file mrcio.cpp. References MrcMode. 01123 {
01124 MrcMode m = MRC_UNKNOWN;
01125 EMUtil::EMDataType em_type = static_cast < EMUtil::EMDataType > (e);
01126
01127 switch (em_type) {
01128 case EMUtil::EM_UCHAR:
01129 m = MRC_UCHAR;
01130 break;
01131 case EMUtil::EM_USHORT:
01132 if (is_complex) {
01133 m = MRC_SHORT_COMPLEX;
01134 }
01135 else {
01136 m = MRC_USHORT;
01137 }
01138 break;
01139 case EMUtil::EM_SHORT:
01140 if (is_complex) {
01141 m = MRC_SHORT_COMPLEX;
01142 }
01143 else {
01144 m = MRC_SHORT;
01145 }
01146 break;
01147 case EMUtil::EM_SHORT_COMPLEX:
01148 case EMUtil::EM_USHORT_COMPLEX:
01149 m = MRC_SHORT_COMPLEX;
01150 break;
01151 case EMUtil::EM_CHAR:
01152 case EMUtil::EM_INT:
01153 case EMUtil::EM_UINT:
01154 case EMUtil::EM_FLOAT:
01155 if (is_complex) {
01156 m = MRC_FLOAT_COMPLEX;
01157 }
01158 else {
01159 m = MRC_FLOAT;
01160 }
01161 break;
01162 case EMUtil::EM_FLOAT_COMPLEX:
01163 m = MRC_FLOAT_COMPLEX;
01164 break;
01165 default:
01166 m = MRC_FLOAT;
01167 }
01168
01169 return m;
01170 }
|
|
|
This is a utility function used to calculate new min/max/mean/sigma when write MRC file as 16 bit or 8 bit. It will write new set of min/max/mean/sigma to mrch. this function needs get the output data storage type from mrch.mode. Definition at line 909 of file mrcio.cpp. References 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. 00910 {
00911 size_t size = mrch.nx * mrch.ny * mrch.nz;
00912 float v = 0.0f; //variable to hold pixel value
00913 double sum = 0.0;
00914 double square_sum = 0.0;
00915 double mean = 0.0;
00916 float min, max;
00917
00918 unsigned char * cdata = 0;
00919 short * sdata = 0;
00920 unsigned short * usdata = 0;
00921
00922 if (mrch.mode == MRC_UCHAR) {
00923 max = 0.0f;
00924 min = UCHAR_MAX;
00925 cdata = (unsigned char *)data;
00926
00927 for (size_t i = 0; i < size; ++i) {
00928 v = (float)(cdata[i]);
00929 #ifdef _WIN32
00930 max = _cpp_max(max,v);
00931 min = _cpp_min(min,v);
00932 #else
00933 max=std::max<float>(max,v);
00934 min=std::min<float>(min,v);
00935 #endif //_WIN32
00936
00937 sum += v;
00938 square_sum += v * v;
00939 }
00940 }
00941 else if (mrch.mode == MRC_SHORT || mrch.mode == MRC_SHORT_COMPLEX) {
00942 max = (float)SHRT_MIN;
00943 min = (float)SHRT_MAX;
00944 sdata = (short *)data;
00945
00946 for (size_t i = 0; i < size; ++i) {
00947 v = (float)(sdata[i]);
00948 #ifdef _WIN32
00949 max = _cpp_max(max,v);
00950 min = _cpp_min(min,v);
00951 #else
00952 max=std::max<float>(max,v);
00953 min=std::min<float>(min,v);
00954 #endif //_WIN32
00955
00956 sum += v;
00957 square_sum += v * v;
00958 }
00959 }
00960 else if (mrch.mode == MRC_USHORT) {
00961 max = 0.0f;
00962 min = (float)USHRT_MAX;
00963 usdata = (unsigned short*)data;
00964
00965 for (size_t i = 0; i < size; ++i) {
00966 v = (float)(usdata[i]);
00967 #ifdef _WIN32
00968 max = _cpp_max(max,v);
00969 min = _cpp_min(min,v);
00970 #else
00971 max=std::max<float>(max,v);
00972 min=std::min<float>(min,v);
00973 #endif //_WIN32
00974
00975 sum += v;
00976 square_sum += v * v;
00977 }
00978 }
00979 else {
00980 throw InvalidCallException("This function is used to write 8bit/16bit mrc file only.");
00981 }
00982
00983 mean = sum/size;
00984 #ifdef _WIN32
00985 float sigma = (float)std::sqrt( _cpp_max(0.0,(square_sum - sum*sum / size)/(size-1)));
00986 #else
00987 float sigma = (float)std::sqrt(std::max<float>(0.0,(square_sum - sum*sum / size)/(size-1)));
00988 #endif //_WIN32
00989
00990 /*change mrch.amin/amax/amean.rms here*/
00991 mrch.amin = min;
00992 mrch.amax = max;
00993 mrch.amean = (float)mean;
00994 mrch.rms = sigma;
00995
00996 MrcHeader mrch2 = mrch;
00997
00998 //endian issue, can't get use_host_endian argument
00999 // bool opposite_endian = false;
01000
01001 // if (!is_new_file) {
01002 // if (is_big_endian != ByteOrder::is_host_big_endian()) {
01003 // opposite_endian = true;
01004 // }
01005 //
01006 // portable_fseek(mrcfile, 0, SEEK_SET);
01007 // }
01008 //
01009 // if (opposite_endian || !use_host_endian) {
01010 // swap_header(mrch2);
01011 // }
01012
01013 portable_fseek(mrcfile, 0, SEEK_SET);
01014
01015 if (fwrite(&mrch2, sizeof(MrcHeader), 1, mrcfile) != 1) {
01016 throw ImageWriteException(filename, "MRC header");
01017 }
01018
01019 portable_fseek(mrcfile, sizeof(MrcHeader), SEEK_SET);
01020 }
|
|
||||||||||||
|
Write CTF data to this image.
Reimplemented from EMAN::ImageIO. Definition at line 1046 of file mrcio.cpp. References CTF_MAGIC, filename, ImageWriteException, EMAN::ImageIO::init(), EMAN::MrcIO::MrcHeader::labels, mrcfile, mrch, and EMAN::Ctf::to_string(). 01047 {
01048 ENTERFUNC;
01049 init();
01050
01051 string ctf_str = ctf.to_string();
01052 sprintf(&mrch.labels[0][0], "%s%s", CTF_MAGIC, ctf_str.c_str());
01053 rewind(mrcfile);
01054
01055 if (fwrite(&mrch, sizeof(MrcHeader), 1, mrcfile) != 1) {
01056 throw ImageWriteException(filename, "write CTF info to header failed");
01057 }
01058 EXITFUNC;
01059 }
|
|
|
Definition at line 48 of file mrcio.cpp. Referenced by read_ctf(), and write_ctf(). |
|
|
|
|
|
Definition at line 272 of file mrcio.h. Referenced by get_nimg(), and read_fei_header(). |
|
|
Definition at line 265 of file mrcio.h. Referenced by read_fei_header(), read_mrc_header(), update_stat(), and write_ctf(). |
|
|
|
|
|
Definition at line 279 of file mrcio.h. Referenced by MrcIO(). |
|
|
Definition at line 280 of file mrcio.h. Referenced by read_fei_header(), and read_mrc_header(). |
|
|
|
|
|
|
|
|
|
|
|
Definition at line 267 of file mrcio.h. Referenced by read_fei_header(), update_stat(), write_ctf(), and ~MrcIO(). |
|
|
Definition at line 271 of file mrcio.h. Referenced by MrcIO(), read_ctf(), read_mrc_header(), update_stat(), and write_ctf(). |
|
|
|
|
|
|
1.3.9.1