#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 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 }
|
|
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 }
|
|
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 }
|
|
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 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 }
|
|
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 }
|
|
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 }
|
|
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 }
|
|
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 }
|
|
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 }
|
|
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 }
|
|
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 }
|
|
Write CTF data to this image.
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 }
|
|
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 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(). |
|
|
|
|