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