#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) |
| 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 = "!$" |
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 is_transpose(false) 00055 { 00056 memset(&mrch, 0, sizeof(MrcHeader)); 00057 is_big_endian = ByteOrder::is_host_big_endian(); 00058 }
|
|
|
Definition at line 60 of file mrcio.cpp. References mrcfile. 00061 {
00062 if (mrcfile) {
00063 fclose(mrcfile);
00064 mrcfile = 0;
00065 }
00066 }
|
|
|
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 }
|
|
|
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 }
|
|
|
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 }
|
|
||||||||||||
|
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 }
|
|
||||||||||||
|
Read CTF data from this image.
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 }
|
|
||||||||||||||||||||
|
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 }
|
|
||||||||||||||||||||
|
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 }
|
|
|
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 }
|
|
|
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 }
|
|
||||||||||||
|
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 }
|
|
||||||||||||||||||||
|
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 }
|
|
|
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 }
|
|
||||||||||||
|
Write CTF data to this image.
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 }
|
|
|
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