#include <emutil.h>
Public Types | |
enum | EMDataType { EM_UNKNOWN, EM_CHAR, EM_UCHAR, EM_SHORT, EM_USHORT, EM_INT, EM_UINT, EM_FLOAT, EM_DOUBLE, EM_SHORT_COMPLEX, EM_USHORT_COMPLEX, EM_FLOAT_COMPLEX } |
Image pixel data type used in EMAN. More... | |
enum | ImageType { IMAGE_UNKNOWN, IMAGE_MRC, IMAGE_SPIDER, IMAGE_SINGLE_SPIDER, IMAGE_IMAGIC, IMAGE_HDF, IMAGE_DM3, IMAGE_TIFF, IMAGE_PGM, IMAGE_LST, IMAGE_PIF, IMAGE_VTK, IMAGE_PNG, IMAGE_SAL, IMAGE_ICOS, IMAGE_EMIM, IMAGE_GATAN2, IMAGE_AMIRA, IMAGE_XPLOR, IMAGE_EM, IMAGE_V4L, IMAGE_JPEG, IMAGE_FITS, IMAGE_LSTFAST, IMAGE_DF3, IMAGE_OMAP } |
Image format types. More... | |
Static Public Member Functions | |
EMData * | vertical_acf (const EMData *image, int maxdy) |
EMData * | make_image_median (const vector< EMData * > &image_list) |
ImageType | get_image_ext_type (const string &file_ext) |
Get an image's format type from its filename extension. | |
ImageType | get_image_type (const string &filename) |
Get an image's format type by processing the first 1K of the image. | |
bool | is_valid_filename (const string &filename) |
Ask whether or not the given filename is a valid EM image filename This is the same thing as checking whether or not the return value of EMUtil.get_image_ext_type is IMAGE_UNKNOWN. | |
int | get_image_count (const string &filename) |
Get the number of images in an image file. | |
ImageIO * | get_imageio (const string &filename, int rw_mode, ImageType image_type=IMAGE_UNKNOWN) |
Get an ImageIO object. | |
const char * | get_imagetype_name (EMUtil::ImageType type) |
Give each image type a meaningful name. | |
const char * | get_datatype_string (EMDataType type) |
Give each data type a meaningful name. | |
void | get_region_dims (const Region *area, int nx, int *area_x, int ny, int *area_y, int nz=1, int *area_z=0) |
Get a region's dimensions. | |
void | get_region_origins (const Region *area, int *p_x0, int *p_y0, int *p_z0=0, int nz=1, int image_index=0) |
Get a region's original locations. | |
void | process_region_io (void *cdata, FILE *file, int rw_mode, int image_index, size_t mode_size, int nx, int ny, int nz=1, const Region *area=0, bool need_flip=false, ImageType imgtype=IMAGE_UNKNOWN, int pre_row=0, int post_row=0) |
Process image region IO. | |
void | process_ascii_region_io (float *data, FILE *file, int rw_mode, int image_index, size_t mode_size, int nx, int ny, int nz, const Region *area, bool has_index_line, int nitems_per_line, const char *outformat) |
Works for regions that are outside the image data dimension area. | |
void | dump_dict (const Dict &dict) |
Dump a Dict object. | |
bool | is_same_size (const EMData *image1, const EMData *image2) |
Check whether two EMData images are of the same size. | |
bool | is_same_ctf (const EMData *image1, const EMData *image2) |
Check whether two EMData images have the same CTF parameters. | |
bool | is_complex_type (EMDataType datatype) |
void | jump_lines (FILE *file, int nlines) |
vector< string > | get_euler_names (const string &euler_type) |
vector< EMObject > | get_all_attributes (const string &file_name, const string &attr_name) |
Get an attribute from a stack of image, returned as a vector. | |
void | getRenderMinMax (float *data, const int nx, const int ny, float &rendermin, float &rendermax, const int nz=1) |
Calculate the min and max pixel value acceptedfor image nomalization, if we did not get them from image attribute dictionary, or they are not valid values rendermin = mean - 3*sigma rendermax = mean + 3*sigma. | |
bool | cuda_available () |
void * | em_malloc (const size_t size) |
void * | em_calloc (const size_t nmemb, const size_t size) |
void * | em_realloc (void *data, const size_t new_size) |
void | em_memset (void *data, const int value, const size_t size) |
void | em_free (void *data) |
void | em_memcpy (void *dst, const void *const src, const size_t size) |
Static Private Member Functions | |
ImageType | fast_get_image_type (const string &filename, const void *first_block, off_t file_size) |
void | jump_lines_by_items (FILE *file, int nitems, int nitems_per_line) |
void | process_numbers_io (FILE *file, int rw_mode, int nitems_per_line, size_t mode_size, int start, int end, float *data, int *p_i, const char *outformat) |
void | exclude_numbers_io (FILE *file, int rw_mode, int nitems_per_line, size_t mode_size, int start, int end, float *data, int *p_i, const char *outformat) |
void | process_lines_io (FILE *file, int rw_mode, int nitems_per_line, size_t mode_size, int nitems, float *data, int *p_i, const char *outformat) |
|
Image pixel data type used in EMAN. EM_U means "EM unsigned". for example, EM_USHORT means EM unsigned short.
Definition at line 92 of file emutil.h. Referenced by dump_dict(). 00093 { 00094 EM_UNKNOWN, 00095 EM_CHAR, 00096 EM_UCHAR, 00097 EM_SHORT, 00098 EM_USHORT, 00099 EM_INT, 00100 EM_UINT, 00101 EM_FLOAT, 00102 EM_DOUBLE, 00103 EM_SHORT_COMPLEX, 00104 EM_USHORT_COMPLEX, 00105 EM_FLOAT_COMPLEX 00106 };
|
|
Image format types.
Definition at line 110 of file emutil.h. Referenced by fast_get_image_type(), get_image_ext_type(), get_image_type(), getRenderMinMax(), and is_valid_filename(). 00111 { 00112 IMAGE_UNKNOWN, 00113 IMAGE_MRC, 00114 IMAGE_SPIDER, 00115 IMAGE_SINGLE_SPIDER, 00116 IMAGE_IMAGIC, 00117 IMAGE_HDF, 00118 IMAGE_DM3, 00119 IMAGE_TIFF, 00120 IMAGE_PGM, 00121 IMAGE_LST, 00122 IMAGE_PIF, 00123 IMAGE_VTK, 00124 IMAGE_PNG, 00125 IMAGE_SAL, 00126 IMAGE_ICOS, 00127 IMAGE_EMIM, 00128 IMAGE_GATAN2, 00129 IMAGE_AMIRA, 00130 IMAGE_XPLOR, 00131 IMAGE_EM, 00132 IMAGE_V4L, 00133 IMAGE_JPEG, 00134 IMAGE_FITS, 00135 IMAGE_LSTFAST, 00136 IMAGE_DF3, 00137 IMAGE_OMAP 00138 };
|
|
Definition at line 333 of file emutil.h. 00333 { 00334 //#ifdef EMAN2_USING_CUDA 00335 // return true; 00336 //#else 00337 return false; 00338 //#endif 00339 }
|
|
Dump a Dict object.
Definition at line 965 of file emutil.cpp. References EMDataType, get_datatype_string(), EMAN::EMObject::is_null(), EMAN::Dict::keys(), EMAN::EMObject::to_str(), and EMAN::Dict::values(). Referenced by main(). 00966 { 00967 vector < string > keys = dict.keys(); 00968 vector < EMObject > values = dict.values(); 00969 00970 for (unsigned int i = 0; i < keys.size(); i++) { 00971 EMObject obj = values[i]; 00972 if( !obj.is_null() ) { 00973 string val = obj.to_str(); 00974 00975 if (keys[i] == "datatype") { 00976 val = get_datatype_string((EMDataType) (int) obj); 00977 } 00978 00979 fprintf(stdout, "%25s\t%s\n", keys[i].c_str(), val.c_str()); 00980 } 00981 } 00982 }
|
|
Definition at line 345 of file emutil.h. 00345 {
00346 return calloc(nmemb,size);
00347 }
|
|
Definition at line 355 of file emutil.h. References data. Referenced by EMAN::EMData::free_memory(), and EMAN::EMData::free_rdata(). 00355 { 00356 free(data); 00357 }
|
|
Definition at line 341 of file emutil.h. Referenced by EMAN::TransformProcessor::transform(). 00341 {
00342 return malloc(size);
00343 }
|
|
Definition at line 359 of file emutil.h. 00359 { 00360 memcpy(dst,src,size); 00361 }
|
|
Definition at line 352 of file emutil.h. References data. 00352 { 00353 memset(data, value, size); 00354 }
|
|
Definition at line 349 of file emutil.h. References data. 00349 {
00350 return realloc(data, new_size);
00351 }
|
|
Definition at line 1387 of file emutil.cpp. References Assert, data, and portable_fseek(). Referenced by process_ascii_region_io(). 01390 { 01391 Assert(file); 01392 Assert(mode_size > 0); 01393 Assert(start >= 0); 01394 Assert(end <= nitems_per_line); 01395 Assert(data); 01396 Assert(p_i); 01397 Assert(outformat); 01398 01399 char line[MAXPATHLEN]; 01400 01401 if (rw_mode == ImageIO::READ_ONLY) { 01402 01403 if (!fgets(line, sizeof(line), file)) { 01404 Assert("read xplor file failed"); 01405 } 01406 01407 int nitems_in_line = (int) (strlen(line) / mode_size); 01408 Assert(end <= nitems_in_line); 01409 01410 vector<float> d(nitems_in_line); 01411 char *pline = line; 01412 01413 for (int i = 0; i < nitems_in_line; i++) { 01414 sscanf(pline, "%f", &d[i]); 01415 pline = pline + (int)mode_size; 01416 } 01417 01418 01419 for (int i = 0; i < start; i++) { 01420 data[*p_i] = d[i]; 01421 (*p_i)++; 01422 } 01423 01424 for (int i = end+1; i < nitems_in_line; i++) { 01425 data[*p_i] = d[i]; 01426 (*p_i)++; 01427 } 01428 } 01429 else { 01430 for (int i = 0; i < start; i++) { 01431 fprintf(file, outformat, data[*p_i]); 01432 (*p_i)++; 01433 } 01434 01435 portable_fseek(file, (end-start+1) * mode_size, SEEK_CUR); 01436 01437 for (int i = end+1; i < nitems_per_line; i++) { 01438 fprintf(file, outformat, data[*p_i]); 01439 (*p_i)++; 01440 } 01441 portable_fseek(file, 1, SEEK_CUR); 01442 } 01443 }
|
|
Definition at line 208 of file emutil.cpp. References Assert, EMAN::Util::get_filename_ext(), get_image_ext_type(), IMAGE_AMIRA, IMAGE_DF3, IMAGE_DM3, IMAGE_EM, IMAGE_GATAN2, IMAGE_HDF, IMAGE_ICOS, IMAGE_IMAGIC, IMAGE_LST, IMAGE_LSTFAST, IMAGE_MRC, IMAGE_OMAP, IMAGE_PGM, IMAGE_PIF, IMAGE_PNG, IMAGE_SAL, IMAGE_SINGLE_SPIDER, IMAGE_SPIDER, IMAGE_TIFF, IMAGE_VTK, IMAGE_XPLOR, ImageType, EMAN::ImagicIO::is_valid(), EMAN::OmapIO::is_valid(), EMAN::EmIO::is_valid(), EMAN::Gatan2IO::is_valid(), EMAN::XplorIO::is_valid(), EMAN::AmiraIO::is_valid(), EMAN::SalIO::is_valid(), EMAN::IcosIO::is_valid(), EMAN::PgmIO::is_valid(), EMAN::VtkIO::is_valid(), EMAN::PifIO::is_valid(), EMAN::SingleSpiderIO::is_valid(), EMAN::SpiderIO::is_valid(), EMAN::LstFastIO::is_valid(), EMAN::LstIO::is_valid(), EMAN::DM3IO::is_valid(), and EMAN::MrcIO::is_valid(). Referenced by get_image_type(). 00211 { 00212 ENTERFUNC; 00213 Assert(filename != ""); 00214 Assert(first_block != 0); 00215 Assert(file_size > 0); 00216 00217 #ifdef ENABLE_V4L2 00218 if (filename.compare(0,5,"/dev/")==0) return IMAGE_V4L; 00219 #endif 00220 00221 string ext = Util::get_filename_ext(filename); 00222 if (ext == "") { 00223 return IMAGE_UNKNOWN; 00224 } 00225 ImageType image_type = get_image_ext_type(ext); 00226 00227 switch (image_type) { 00228 case IMAGE_MRC: 00229 if (MrcIO::is_valid(first_block, file_size)) { 00230 return IMAGE_MRC; 00231 } 00232 break; 00233 case IMAGE_DM3: 00234 if (DM3IO::is_valid(first_block)) { 00235 return IMAGE_DM3; 00236 } 00237 break; 00238 #ifdef EM_HDF5 00239 case IMAGE_HDF: 00240 if (HdfIO2::is_valid(first_block)) { 00241 return IMAGE_HDF; 00242 } 00243 break; 00244 #endif 00245 case IMAGE_LST: 00246 if (LstIO::is_valid(first_block)) { 00247 return IMAGE_LST; 00248 } 00249 break; 00250 case IMAGE_LSTFAST: 00251 if (LstFastIO::is_valid(first_block)) { 00252 return IMAGE_LSTFAST; 00253 } 00254 break; 00255 #ifdef EM_TIFF 00256 case IMAGE_TIFF: 00257 if (TiffIO::is_valid(first_block)) { 00258 return IMAGE_TIFF; 00259 } 00260 break; 00261 #endif 00262 case IMAGE_SPIDER: 00263 if (SpiderIO::is_valid(first_block)) { 00264 return IMAGE_SPIDER; 00265 } 00266 break; 00267 case IMAGE_SINGLE_SPIDER: 00268 if (SingleSpiderIO::is_valid(first_block)) { 00269 return IMAGE_SINGLE_SPIDER; 00270 } 00271 break; 00272 case IMAGE_PIF: 00273 if (PifIO::is_valid(first_block)) { 00274 return IMAGE_PIF; 00275 } 00276 break; 00277 #ifdef EM_PNG 00278 case IMAGE_PNG: 00279 if (PngIO::is_valid(first_block)) { 00280 return IMAGE_PNG; 00281 } 00282 break; 00283 #endif 00284 case IMAGE_VTK: 00285 if (VtkIO::is_valid(first_block)) { 00286 return IMAGE_VTK; 00287 } 00288 break; 00289 case IMAGE_PGM: 00290 if (PgmIO::is_valid(first_block)) { 00291 return IMAGE_PGM; 00292 } 00293 break; 00294 case IMAGE_ICOS: 00295 if (IcosIO::is_valid(first_block)) { 00296 return IMAGE_ICOS; 00297 } 00298 break; 00299 case IMAGE_SAL: 00300 if (SalIO::is_valid(first_block)) { 00301 return IMAGE_SAL; 00302 } 00303 break; 00304 case IMAGE_AMIRA: 00305 if (AmiraIO::is_valid(first_block)) { 00306 return IMAGE_AMIRA; 00307 } 00308 break; 00309 case IMAGE_XPLOR: 00310 if (XplorIO::is_valid(first_block)) { 00311 return IMAGE_XPLOR; 00312 } 00313 break; 00314 case IMAGE_GATAN2: 00315 if (Gatan2IO::is_valid(first_block)) { 00316 return IMAGE_GATAN2; 00317 } 00318 break; 00319 case IMAGE_EM: 00320 if (EmIO::is_valid(first_block, file_size)) { 00321 return IMAGE_EM; 00322 } 00323 break; 00324 case IMAGE_DF3: 00325 if (EmIO::is_valid(first_block, file_size)) { 00326 return IMAGE_DF3; 00327 } 00328 break; 00329 case IMAGE_OMAP: 00330 if (OmapIO::is_valid(first_block, file_size)) { 00331 return IMAGE_OMAP; 00332 } 00333 break; 00334 case IMAGE_IMAGIC: 00335 if (ImagicIO::is_valid(first_block)) { 00336 return IMAGE_IMAGIC; 00337 } 00338 break; 00339 default: 00340 return IMAGE_UNKNOWN; 00341 } 00342 EXITFUNC; 00343 return IMAGE_UNKNOWN; 00344 }
|
|
Get an attribute from a stack of image, returned as a vector.
Definition at line 1507 of file emutil.cpp. References Assert, read_images(), and v. 01508 { 01509 vector<EMObject> v; 01510 01511 Assert(file_name != ""); 01512 Assert(attr_name != ""); 01513 01514 vector< shared_ptr<EMData> > vpImg = EMData::read_images(file_name, vector<int>(), true); 01515 vector< shared_ptr<EMData> >::const_iterator iter; 01516 for(iter = vpImg.begin(); iter!=vpImg.end(); ++iter) { 01517 v.push_back((*iter)->get_attr_default(attr_name)); 01518 } 01519 01520 return v; 01521 }
|
|
Give each data type a meaningful name.
Definition at line 704 of file emutil.cpp. References EM_CHAR, EM_DOUBLE, EM_FLOAT, EM_FLOAT_COMPLEX, EM_INT, EM_SHORT, EM_SHORT_COMPLEX, EM_UCHAR, EM_UINT, EM_UNKNOWN, EM_USHORT, and EM_USHORT_COMPLEX. Referenced by dump_dict(). 00705 { 00706 switch (type) { 00707 case EM_CHAR: 00708 return "CHAR"; 00709 case EM_UCHAR: 00710 return "UNSIGNED CHAR"; 00711 case EM_SHORT: 00712 return "SHORT"; 00713 case EM_USHORT: 00714 return "UNSIGNED SHORT"; 00715 case EM_INT: 00716 return "INT"; 00717 case EM_UINT: 00718 return "UNSIGNED INT"; 00719 case EM_FLOAT: 00720 return "FLOAT"; 00721 case EM_DOUBLE: 00722 return "DOUBLE"; 00723 case EM_SHORT_COMPLEX: 00724 return "SHORT_COMPLEX"; 00725 case EM_USHORT_COMPLEX: 00726 return "USHORT_COMPLEX"; 00727 case EM_FLOAT_COMPLEX: 00728 return "FLOAT_COMPLEX"; 00729 case EM_UNKNOWN: 00730 return "UNKNOWN"; 00731 } 00732 return "UNKNOWN"; 00733 }
|
|
Definition at line 1463 of file emutil.cpp. 01464 { 01465 vector<string> v; 01466 string b = "euler_"; 01467 01468 if (euler_type == "EMAN") { 01469 v.push_back(b + "alt"); 01470 v.push_back(b + "az"); 01471 v.push_back(b + "phi"); 01472 } 01473 else if (euler_type == "MRC") { 01474 v.push_back(b + "theta"); 01475 v.push_back(b + "phi"); 01476 v.push_back(b + "omega"); 01477 } 01478 else if (euler_type == "IMAGIC") { 01479 v.push_back(b + "alpha"); 01480 v.push_back(b + "beta"); 01481 v.push_back(b + "gamma"); 01482 } 01483 else if (euler_type == "SPIDER") { 01484 v.push_back(b + "phi"); 01485 v.push_back(b + "theta"); 01486 v.push_back(b + "gamma"); 01487 } 01488 else if (euler_type == "SPIN" || 01489 euler_type == "SGIROT") { 01490 v.push_back(b + "q"); 01491 v.push_back(b + "n1"); 01492 v.push_back(b + "n2"); 01493 v.push_back(b + "n3"); 01494 } 01495 01496 else if (euler_type == "QUATERNION") { 01497 v.push_back(b + "e0"); 01498 v.push_back(b + "e1"); 01499 v.push_back(b + "e2"); 01500 v.push_back(b + "e3"); 01501 } 01502 01503 return v; 01504 }
|
|
Get the number of images in an image file.
Definition at line 467 of file emutil.cpp. References Assert, get_imageio(), and EMAN::ImageIO::get_nimg(). Referenced by EMAN::PCA::dopca_ooc(), EMAN::PCA::Lanczos_ooc(), main(), ReadStackandDist(), and ReadStackandDist_Cart(). 00468 { 00469 ENTERFUNC; 00470 Assert(filename != ""); 00471 00472 int nimg = 0; 00473 ImageIO *imageio = get_imageio(filename, ImageIO::READ_ONLY); 00474 00475 if (imageio) { 00476 nimg = imageio->get_nimg(); 00477 } 00478 #ifndef IMAGEIO_CACHE 00479 if( imageio ) 00480 { 00481 delete imageio; 00482 imageio = 0; 00483 } 00484 #endif 00485 EXITFUNC; 00486 return nimg; 00487 }
|
|
Get an image's format type from its filename extension.
Definition at line 62 of file emutil.cpp. References ImageType. Referenced by fast_get_image_type(), and is_valid_filename(). 00063 { 00064 ENTERFUNC; 00065 static bool initialized = false; 00066 static map < string, ImageType > imagetypes; 00067 00068 if (!initialized) { 00069 imagetypes["rec"] = IMAGE_MRC; 00070 imagetypes["mrc"] = IMAGE_MRC; 00071 imagetypes["MRC"] = IMAGE_MRC; 00072 imagetypes["ali"] = IMAGE_MRC; 00073 00074 imagetypes["tnf"] = IMAGE_MRC; 00075 imagetypes["TNF"] = IMAGE_MRC; 00076 00077 imagetypes["ccp4"] = IMAGE_MRC; 00078 imagetypes["map"] = IMAGE_MRC; 00079 00080 imagetypes["dm3"] = IMAGE_DM3; 00081 imagetypes["DM3"] = IMAGE_DM3; 00082 00083 imagetypes["spi"] = IMAGE_SPIDER; 00084 imagetypes["SPI"] = IMAGE_SPIDER; 00085 00086 imagetypes["spider"] = IMAGE_SPIDER; 00087 imagetypes["SPIDER"] = IMAGE_SPIDER; 00088 00089 imagetypes["spidersingle"] = IMAGE_SINGLE_SPIDER; 00090 imagetypes["SPIDERSINGLE"] = IMAGE_SINGLE_SPIDER; 00091 00092 imagetypes["singlespider"] = IMAGE_SINGLE_SPIDER; 00093 imagetypes["SINGLESPIDER"] = IMAGE_SINGLE_SPIDER; 00094 00095 imagetypes["img"] = IMAGE_IMAGIC; 00096 imagetypes["IMG"] = IMAGE_IMAGIC; 00097 00098 imagetypes["hed"] = IMAGE_IMAGIC; 00099 imagetypes["HED"] = IMAGE_IMAGIC; 00100 00101 imagetypes["imagic"] = IMAGE_IMAGIC; 00102 imagetypes["IMAGIC"] = IMAGE_IMAGIC; 00103 00104 imagetypes["pgm"] = IMAGE_PGM; 00105 imagetypes["PGM"] = IMAGE_PGM; 00106 00107 imagetypes["lst"] = IMAGE_LST; 00108 imagetypes["LST"] = IMAGE_LST; 00109 00110 imagetypes["lsx"] = IMAGE_LSTFAST; // but .lst or another extension would also be ok 00111 imagetypes["LSX"] = IMAGE_LSTFAST; 00112 00113 imagetypes["pif"] = IMAGE_PIF; 00114 imagetypes["PIF"] = IMAGE_PIF; 00115 00116 imagetypes["png"] = IMAGE_PNG; 00117 imagetypes["PNG"] = IMAGE_PNG; 00118 00119 imagetypes["h5"] = IMAGE_HDF; 00120 imagetypes["H5"] = IMAGE_HDF; 00121 00122 imagetypes["hd5"] = IMAGE_HDF; 00123 imagetypes["HD5"] = IMAGE_HDF; 00124 00125 imagetypes["hdf"] = IMAGE_HDF; 00126 imagetypes["HDF"] = IMAGE_HDF; 00127 00128 imagetypes["tif"] = IMAGE_TIFF; 00129 imagetypes["TIF"] = IMAGE_TIFF; 00130 00131 imagetypes["tiff"] = IMAGE_TIFF; 00132 imagetypes["TIFF"] = IMAGE_TIFF; 00133 00134 imagetypes["fts"] = IMAGE_FITS; 00135 imagetypes["FTS"] = IMAGE_FITS; 00136 00137 imagetypes["vtk"] = IMAGE_VTK; 00138 imagetypes["VTK"] = IMAGE_VTK; 00139 00140 imagetypes["hdr"] = IMAGE_SAL; 00141 imagetypes["HDR"] = IMAGE_SAL; 00142 00143 imagetypes["sal"] = IMAGE_SAL; 00144 imagetypes["SAL"] = IMAGE_SAL; 00145 00146 imagetypes["map"] = IMAGE_ICOS; 00147 imagetypes["MAP"] = IMAGE_ICOS; 00148 00149 imagetypes["icos"] = IMAGE_ICOS; 00150 imagetypes["ICOS"] = IMAGE_ICOS; 00151 00152 imagetypes["am"] = IMAGE_AMIRA; 00153 imagetypes["AM"] = IMAGE_AMIRA; 00154 00155 imagetypes["amira"] = IMAGE_AMIRA; 00156 imagetypes["AMIRA"] = IMAGE_AMIRA; 00157 00158 imagetypes["emim"] = IMAGE_EMIM; 00159 imagetypes["EMIM"] = IMAGE_EMIM; 00160 00161 imagetypes["xplor"] = IMAGE_XPLOR; 00162 imagetypes["XPLOR"] = IMAGE_XPLOR; 00163 00164 imagetypes["em"] = IMAGE_EM; 00165 imagetypes["EM"] = IMAGE_EM; 00166 00167 imagetypes["dm2"] = IMAGE_GATAN2; 00168 imagetypes["DM2"] = IMAGE_GATAN2; 00169 00170 imagetypes["v4l"] = IMAGE_V4L; 00171 imagetypes["V4L"] = IMAGE_V4L; 00172 00173 imagetypes["jpg"] = IMAGE_JPEG; 00174 imagetypes["JPG"] = IMAGE_JPEG; 00175 imagetypes["jpeg"] = IMAGE_JPEG; 00176 imagetypes["JPEG"] = IMAGE_JPEG; 00177 00178 imagetypes["df3"] = IMAGE_DF3; 00179 imagetypes["DF3"] = IMAGE_DF3; 00180 00181 imagetypes["Omap"] = IMAGE_OMAP; 00182 imagetypes["omap"] = IMAGE_OMAP; 00183 imagetypes["OMAP"] = IMAGE_OMAP; 00184 imagetypes["BRIX"] = IMAGE_OMAP; 00185 imagetypes["brix"] = IMAGE_OMAP; 00186 imagetypes["DSN6"] = IMAGE_OMAP; 00187 00188 initialized = true; 00189 } 00190 00191 ImageType result = IMAGE_UNKNOWN; 00192 00193 if (imagetypes.find(file_ext) != imagetypes.end()) { 00194 result = imagetypes[file_ext]; 00195 } 00196 00197 EXITFUNC; 00198 return result; 00199 }
|
|
Get an image's format type by processing the first 1K of the image.
Definition at line 347 of file emutil.cpp. References Assert, EMAN::Util::change_filename_ext(), fast_get_image_type(), FileAccessException, EMAN::Util::get_filename_ext(), ImageFormatException, ImageType, in, EMAN::Df3IO::is_valid(), EMAN::ImagicIO::is_valid(), EMAN::OmapIO::is_valid(), EMAN::EmIO::is_valid(), EMAN::FitsIO::is_valid(), EMAN::Gatan2IO::is_valid(), EMAN::XplorIO::is_valid(), EMAN::AmiraIO::is_valid(), EMAN::SalIO::is_valid(), EMAN::IcosIO::is_valid(), EMAN::PgmIO::is_valid(), EMAN::VtkIO::is_valid(), EMAN::PifIO::is_valid(), EMAN::LstFastIO::is_valid(), EMAN::LstIO::is_valid(), EMAN::DM3IO::is_valid(), EMAN::MrcIO::is_valid(), EMAN::SingleSpiderIO::is_valid(), EMAN::SpiderIO::is_valid(), LOGERR, portable_fseek(), and portable_ftell(). Referenced by get_imageio(), getRenderMinMax(), and main(). 00348 { 00349 ENTERFUNC; 00350 Assert(in_filename != ""); 00351 00352 #ifdef ENABLE_V4L2 00353 if (in_filename.compare(0,5,"/dev/")==0) return IMAGE_V4L; 00354 #endif 00355 00356 string filename = in_filename; 00357 00358 string old_ext = Util::get_filename_ext(filename); 00359 if (old_ext == ImagicIO::IMG_EXT) { 00360 filename = Util::change_filename_ext(filename, ImagicIO::HED_EXT); 00361 } 00362 00363 FILE *in = fopen(filename.c_str(), "rb"); 00364 if (!in) { 00365 throw FileAccessException(filename); 00366 } 00367 00368 char first_block[1024]; 00369 size_t n = fread(first_block, sizeof(char), sizeof(first_block), in); 00370 portable_fseek(in, 0, SEEK_END); 00371 off_t file_size = portable_ftell(in); 00372 00373 if (n == 0) { 00374 LOGERR("file '%s' is an empty file", filename.c_str()); 00375 fclose(in); 00376 return IMAGE_UNKNOWN; 00377 } 00378 fclose(in); 00379 00380 ImageType image_type = fast_get_image_type(filename, first_block, file_size); 00381 if (image_type != IMAGE_UNKNOWN) { 00382 return image_type; 00383 } 00384 00385 if (SpiderIO::is_valid(first_block)) { 00386 image_type = IMAGE_SPIDER; 00387 } 00388 else if (SingleSpiderIO::is_valid(first_block)) { 00389 image_type = IMAGE_SINGLE_SPIDER; 00390 } 00391 else if (MrcIO::is_valid(first_block, file_size)) { 00392 image_type = IMAGE_MRC; 00393 } 00394 else if (DM3IO::is_valid(first_block)) { 00395 image_type = IMAGE_DM3; 00396 } 00397 #ifdef EM_HDF5 00398 else if (HdfIO2::is_valid(first_block)) { 00399 image_type = IMAGE_HDF; 00400 } 00401 #endif 00402 else if (LstIO::is_valid(first_block)) { 00403 image_type = IMAGE_LST; 00404 } 00405 else if (LstFastIO::is_valid(first_block)) { 00406 image_type = IMAGE_LSTFAST; 00407 } 00408 #ifdef EM_TIFF 00409 else if (TiffIO::is_valid(first_block)) { 00410 image_type = IMAGE_TIFF; 00411 } 00412 #endif 00413 else if (PifIO::is_valid(first_block)) { 00414 image_type = IMAGE_PIF; 00415 } 00416 #ifdef EM_PNG 00417 else if (PngIO::is_valid(first_block)) { 00418 image_type = IMAGE_PNG; 00419 } 00420 #endif 00421 else if (VtkIO::is_valid(first_block)) { 00422 image_type = IMAGE_VTK; 00423 } 00424 else if (PgmIO::is_valid(first_block)) { 00425 image_type = IMAGE_PGM; 00426 } 00427 else if (IcosIO::is_valid(first_block)) { 00428 image_type = IMAGE_ICOS; 00429 } 00430 else if (SalIO::is_valid(first_block)) { 00431 image_type = IMAGE_SAL; 00432 } 00433 else if (AmiraIO::is_valid(first_block)) { 00434 image_type = IMAGE_AMIRA; 00435 } 00436 else if (XplorIO::is_valid(first_block)) { 00437 image_type = IMAGE_XPLOR; 00438 } 00439 else if (Gatan2IO::is_valid(first_block)) { 00440 image_type = IMAGE_GATAN2; 00441 } 00442 else if (FitsIO::is_valid(first_block)) { 00443 image_type = IMAGE_FITS; 00444 } 00445 else if (EmIO::is_valid(first_block, file_size)) { 00446 image_type = IMAGE_EM; 00447 } 00448 else if(OmapIO::is_valid(first_block, file_size)) { 00449 image_type = IMAGE_OMAP; 00450 } 00451 else if (ImagicIO::is_valid(first_block)) { 00452 image_type = IMAGE_IMAGIC; 00453 } 00454 else if (Df3IO::is_valid(first_block)) { 00455 image_type = IMAGE_DF3; 00456 } 00457 else { 00458 //LOGERR("I don't know this image's type: '%s'", filename.c_str()); 00459 throw ImageFormatException("invalid image type"); 00460 } 00461 00462 EXITFUNC; 00463 return image_type; 00464 }
|
|
Get an ImageIO object. It may be a newly created object. Or an object stored in the cache.
Definition at line 490 of file emutil.cpp. References EMAN::GlobalCache::add_imageio(), Assert, get_image_type(), EMAN::GlobalCache::get_imageio(), IMAGE_AMIRA, IMAGE_DF3, IMAGE_DM3, IMAGE_EM, IMAGE_FITS, IMAGE_GATAN2, IMAGE_HDF, IMAGE_ICOS, IMAGE_IMAGIC, IMAGE_JPEG, IMAGE_LST, IMAGE_LSTFAST, IMAGE_MRC, IMAGE_OMAP, IMAGE_PGM, IMAGE_PIF, IMAGE_PNG, IMAGE_SAL, IMAGE_SINGLE_SPIDER, IMAGE_SPIDER, IMAGE_TIFF, IMAGE_V4L, IMAGE_VTK, IMAGE_XPLOR, ImageFormatException, and EMAN::GlobalCache::instance(). Referenced by EMAN::LstIO::calc_ref_image_index(), EMAN::LstFastIO::calc_ref_image_index(), get_image_count(), and EMAN::EMData::read_image(). 00492 { 00493 ENTERFUNC; 00494 Assert(filename != ""); 00495 Assert(rw == ImageIO::READ_ONLY || 00496 rw == ImageIO::READ_WRITE || 00497 rw == ImageIO::WRITE_ONLY); 00498 00499 ImageIO *imageio = 0; 00500 #ifdef IMAGEIO_CACHE 00501 imageio = GlobalCache::instance()->get_imageio(filename, rw); 00502 if (imageio) { 00503 return imageio; 00504 } 00505 #endif 00506 00507 ImageIO::IOMode rw_mode = static_cast < ImageIO::IOMode > (rw); 00508 00509 if (image_type == IMAGE_UNKNOWN) { 00510 if(rw == ImageIO::WRITE_ONLY || rw == ImageIO::READ_WRITE) { 00511 throw ImageFormatException("writing to this image format not supported."); 00512 } 00513 00514 image_type = get_image_type(filename); 00515 } 00516 00517 switch (image_type) { 00518 #ifdef ENABLE_V4L2 00519 case IMAGE_V4L: 00520 imageio = new V4L2IO(filename, rw_mode); 00521 break; 00522 #endif 00523 case IMAGE_MRC: 00524 imageio = new MrcIO(filename, rw_mode); 00525 break; 00526 case IMAGE_IMAGIC: 00527 imageio = new ImagicIO2(filename, rw_mode); 00528 if (rw_mode==ImageIO::READ_ONLY && ((ImagicIO2 *)imageio)->init_test()==-1 ) { 00529 delete imageio; 00530 imageio = new ImagicIO(filename, rw_mode); 00531 } 00532 break; 00533 case IMAGE_DM3: 00534 imageio = new DM3IO(filename, rw_mode); 00535 break; 00536 #ifdef EM_TIFF 00537 case IMAGE_TIFF: 00538 imageio = new TiffIO(filename, rw_mode); 00539 break; 00540 #endif 00541 #ifdef EM_HDF5 00542 case IMAGE_HDF: 00543 imageio = new HdfIO2(filename, rw_mode); 00544 if (((HdfIO2 *)imageio)->init_test()==-1) { 00545 delete imageio; 00546 imageio = new HdfIO(filename, rw_mode); 00547 } 00548 break; 00549 #endif 00550 case IMAGE_LST: 00551 imageio = new LstIO(filename, rw_mode); 00552 break; 00553 case IMAGE_LSTFAST: 00554 imageio = new LstFastIO(filename, rw_mode); 00555 break; 00556 case IMAGE_PIF: 00557 imageio = new PifIO(filename, rw_mode); 00558 break; 00559 case IMAGE_VTK: 00560 imageio = new VtkIO(filename, rw_mode); 00561 break; 00562 case IMAGE_SPIDER: 00563 imageio = new SpiderIO(filename, rw_mode); 00564 break; 00565 case IMAGE_SINGLE_SPIDER: 00566 imageio = new SingleSpiderIO(filename, rw_mode); 00567 break; 00568 case IMAGE_PGM: 00569 imageio = new PgmIO(filename, rw_mode); 00570 break; 00571 #ifdef EM_JPEG 00572 case IMAGE_JPEG: 00573 imageio = new JpegIO(filename,rw_mode); 00574 break; 00575 #endif 00576 case IMAGE_ICOS: 00577 imageio = new IcosIO(filename, rw_mode); 00578 break; 00579 #ifdef EM_PNG 00580 case IMAGE_PNG: 00581 imageio = new PngIO(filename, rw_mode); 00582 break; 00583 #endif 00584 case IMAGE_SAL: 00585 imageio = new SalIO(filename, rw_mode); 00586 break; 00587 case IMAGE_AMIRA: 00588 imageio = new AmiraIO(filename, rw_mode); 00589 break; 00590 case IMAGE_GATAN2: 00591 imageio = new Gatan2IO(filename, rw_mode); 00592 break; 00593 case IMAGE_EM: 00594 imageio = new EmIO(filename, rw_mode); 00595 break; 00596 case IMAGE_XPLOR: 00597 imageio = new XplorIO(filename, rw_mode); 00598 break; 00599 case IMAGE_FITS: 00600 imageio = new FitsIO(filename, rw_mode); 00601 break; 00602 case IMAGE_DF3: 00603 imageio = new Df3IO(filename, rw_mode); 00604 break; 00605 case IMAGE_OMAP: 00606 imageio = new OmapIO(filename, rw_mode); 00607 break; 00608 default: 00609 break; 00610 } 00611 #ifdef IMAGEIO_CACHE 00612 GlobalCache::instance()->add_imageio(filename, rw, imageio); 00613 #endif 00614 EXITFUNC; 00615 return imageio; 00616 }
|
|
Give each image type a meaningful name.
Definition at line 620 of file emutil.cpp. References IMAGE_AMIRA, IMAGE_DF3, IMAGE_DM3, IMAGE_EM, IMAGE_EMIM, IMAGE_FITS, IMAGE_GATAN2, IMAGE_HDF, IMAGE_ICOS, IMAGE_IMAGIC, IMAGE_JPEG, IMAGE_LST, IMAGE_LSTFAST, IMAGE_MRC, IMAGE_OMAP, IMAGE_PGM, IMAGE_PIF, IMAGE_PNG, IMAGE_SAL, IMAGE_SINGLE_SPIDER, IMAGE_SPIDER, IMAGE_TIFF, IMAGE_UNKNOWN, IMAGE_V4L, IMAGE_VTK, and IMAGE_XPLOR. Referenced by main(). 00621 { 00622 switch (t) { 00623 case IMAGE_V4L: 00624 return "V4L2"; 00625 break; 00626 case IMAGE_MRC: 00627 return "MRC"; 00628 break; 00629 case IMAGE_SPIDER: 00630 return "SPIDER"; 00631 break; 00632 case IMAGE_SINGLE_SPIDER: 00633 return "Single-SPIDER"; 00634 break; 00635 case IMAGE_IMAGIC: 00636 return "IMAGIC"; 00637 break; 00638 case IMAGE_PGM: 00639 return "PGM"; 00640 break; 00641 case IMAGE_LST: 00642 return "LST"; 00643 break; 00644 case IMAGE_LSTFAST: 00645 return "Fast LST"; 00646 break; 00647 case IMAGE_PIF: 00648 return "PIF"; 00649 break; 00650 case IMAGE_PNG: 00651 return "PNG"; 00652 break; 00653 case IMAGE_HDF: 00654 return "HDF5"; 00655 break; 00656 case IMAGE_DM3: 00657 return "GatanDM3"; 00658 break; 00659 case IMAGE_TIFF: 00660 return "TIFF"; 00661 break; 00662 case IMAGE_VTK: 00663 return "VTK"; 00664 break; 00665 case IMAGE_SAL: 00666 return "HDR"; 00667 break; 00668 case IMAGE_ICOS: 00669 return "ICOS_MAP"; 00670 break; 00671 case IMAGE_EMIM: 00672 return "EMIM"; 00673 break; 00674 case IMAGE_GATAN2: 00675 return "GatanDM2"; 00676 break; 00677 case IMAGE_JPEG: 00678 return "JPEG"; 00679 break; 00680 case IMAGE_AMIRA: 00681 return "AmiraMesh"; 00682 break; 00683 case IMAGE_XPLOR: 00684 return "XPLOR"; 00685 break; 00686 case IMAGE_EM: 00687 return "EM"; 00688 break; 00689 case IMAGE_FITS: 00690 return "FITS"; 00691 break; 00692 case IMAGE_DF3: 00693 return "DF3"; 00694 break; 00695 case IMAGE_OMAP: 00696 return "OMAP"; 00697 break; 00698 case IMAGE_UNKNOWN: 00699 return "unknown"; 00700 } 00701 return "unknown"; 00702 }
|
|
Get a region's dimensions.
Definition at line 735 of file emutil.cpp. References Assert, EMAN::Region::get_ndim(), EMAN::Region::get_size(), and EMAN::Vec3i. Referenced by process_ascii_region_io(), process_region_io(), EMAN::MrcIO::read_fei_header(), and EMAN::MrcIO::read_mrc_header(). 00737 { 00738 Assert(area_x); 00739 Assert(area_y); 00740 00741 if (!area) { 00742 *area_x = nx; 00743 *area_y = ny; 00744 if (area_z) { 00745 *area_z = nz; 00746 } 00747 } 00748 else { 00749 Vec3i size = area->get_size(); 00750 *area_x = size[0]; 00751 *area_y = size[1]; 00752 00753 if (area_z) { 00754 if (area->get_ndim() > 2 && nz > 1) { 00755 *area_z = size[2]; 00756 } 00757 else { 00758 *area_z = 1; 00759 } 00760 } 00761 00762 } 00763 }
|
|
Get a region's original locations.
Definition at line 765 of file emutil.cpp. References Assert, EMAN::Region::get_ndim(), and EMAN::Region::origin. 00767 { 00768 Assert(p_x0); 00769 Assert(p_y0); 00770 00771 if (area) { 00772 *p_x0 = static_cast < int >(area->origin[0]); 00773 *p_y0 = static_cast < int >(area->origin[1]); 00774 00775 if (p_z0 && nz > 1 && area->get_ndim() > 2) { 00776 *p_z0 = static_cast < int >(area->origin[2]); 00777 } 00778 } 00779 else { 00780 *p_x0 = 0; 00781 *p_y0 = 0; 00782 if (p_z0) { 00783 *p_z0 = nz > 1 ? 0 : image_index; 00784 } 00785 } 00786 }
|
|
Calculate the min and max pixel value acceptedfor image nomalization, if we did not get them from image attribute dictionary, or they are not valid values rendermin = mean - 3*sigma rendermax = mean + 3*sigma.
Definition at line 1523 of file emutil.cpp. References data, get_image_type(), ImageFormatException, ImageType, EMAN::EMObject::init(), key, max, min, nx, ny, and sqrt(). 01524 { 01525 #ifdef _WIN32 01526 if (rendermax<=rendermin || _isnan(rendermin) || _isnan(rendermax)) { 01527 #else 01528 if (rendermax<=rendermin || std::isnan(rendermin) || std::isnan(rendermax)) { 01529 #endif 01530 float m=0.0f,s=0.0f; 01531 01532 size_t size = (size_t)nx*ny*nz; 01533 float min=data[0],max=data[0]; 01534 01535 for (size_t i=0; i<size; ++i) { m+=data[i]; s+=data[i]*data[i]; min=data[i]<min?data[i]:min; max=data[i]>max?data[i]:max; } 01536 m/=(float)(size); 01537 s=sqrt(s/(float)(size)-m*m); 01538 #ifdef _WIN32 01539 if (s<=0 || _isnan(s)) s=1.0; // this means all data values are the same 01540 #else 01541 if (s<=0 || std::isnan(s)) s=1.0; // this means all data values are the same 01542 #endif //_WIN32 01543 rendermin=m-s*5.0f; 01544 rendermax=m+s*5.0f; 01545 if (rendermin<=min) rendermin=min; 01546 if (rendermax>=max) rendermax=max; 01547 } 01548 }
|
|
Definition at line 995 of file emutil.cpp. References EM_SHORT_COMPLEX, and EM_USHORT_COMPLEX. Referenced by EMAN::TestUtil::make_image_file_by_mode(), and EMAN::TestUtil::verify_image_file_by_mode(). 00996 { 00997 if (datatype == EM_SHORT_COMPLEX || 00998 datatype == EM_USHORT_COMPLEX || 00999 datatype == EM_FLOAT_COMPLEX) { 01000 return true; 01001 } 01002 return false; 01003 }
|
|
Check whether two EMData images have the same CTF parameters.
Definition at line 1107 of file emutil.cpp. References EMAN::Ctf::equal(), EMAN::EMData::get_ctf(), EMAN::EMData::has_ctff(), and NullPointerException. Referenced by main(). 01108 { 01109 if (!image1) { 01110 throw NullPointerException("image1 is NULL"); 01111 } 01112 if (!image2) { 01113 throw NullPointerException("image2 is NULL"); 01114 } 01115 01116 Ctf *ctf1 = image1->get_ctf(); 01117 Ctf *ctf2 = image2->get_ctf(); 01118 01119 if ((!ctf1 && !ctf2) && (image1->has_ctff() == false && image2->has_ctff() == false)) { 01120 return true; 01121 } 01122 01123 if (ctf1 && ctf2) { 01124 bool result = ctf1->equal(ctf2); 01125 delete ctf1; 01126 ctf1 = 0; 01127 delete ctf2; 01128 ctf2 = 0; 01129 01130 return result; 01131 } 01132 return false; 01133 }
|
|
Check whether two EMData images are of the same size.
Definition at line 985 of file emutil.cpp. References EMAN::EMData::get_xsize(), EMAN::EMData::get_ysize(), and EMAN::EMData::get_zsize(). Referenced by EMAN::CtfAverager::add_image(), EMAN::CtfCAutoAverager::add_image(), EMAN::CtfCWautoAverager::add_image(), EMAN::IterationAverager::add_image(), EMAN::MinMaxAverager::add_image(), EMAN::ImageAverager::add_image(), EMAN::TomoAverager::add_image(), EMAN::TranslationalAligner::align(), EMAN::NormalizeMaskProcessor::calc_mean(), EMAN::NormalizeMaskProcessor::calc_sigma(), EMAN::IndexMaskFileProcessor::process_inplace(), and EMAN::Cmp::validate_input_args(). 00986 { 00987 if (em1->get_xsize() == em2->get_xsize() && 00988 em1->get_ysize() == em2->get_ysize() && 00989 em1->get_zsize() == em2->get_zsize()) { 00990 return true; 00991 } 00992 return false; 00993 }
|
|
Ask whether or not the given filename is a valid EM image filename This is the same thing as checking whether or not the return value of EMUtil.get_image_ext_type is IMAGE_UNKNOWN.
Definition at line 203 of file emutil.cpp. References get_image_ext_type(), and ImageType. 00203 { 00204 ImageType type = get_image_ext_type(Util::get_filename_ext(filename)); 00205 return (type != IMAGE_UNKNOWN); 00206 }
|
|
Definition at line 1326 of file emutil.cpp. References Assert. Referenced by jump_lines_by_items(), and process_ascii_region_io(). 01327 { 01328 Assert(file); 01329 01330 if (nlines > 0) { 01331 char line[MAXPATHLEN]; 01332 for (int l = 0; l < nlines; l++) { 01333 if (!fgets(line, sizeof(line), file)) { 01334 Assert("read xplor file failed"); 01335 } 01336 } 01337 } 01338 }
|
|
Definition at line 1307 of file emutil.cpp. References Assert, and jump_lines(). Referenced by process_ascii_region_io(). 01308 { 01309 Assert(file); 01310 Assert(nitems_per_line > 0); 01311 01312 if (nitems <= 0) { 01313 return; 01314 } 01315 01316 int nlines = nitems / nitems_per_line; 01317 if ((nitems % nitems_per_line) != 0) { 01318 nlines++; 01319 } 01320 if (nlines > 0) { 01321 jump_lines(file, nlines); 01322 } 01323 }
|
|
Definition at line 1042 of file emutil.cpp. References EMAN::EMData::get_data(), EMAN::EMData::get_xsize(), EMAN::EMData::get_ysize(), EMAN::EMData::get_zsize(), EMAN::EMData::set_size(), EMAN::EMData::update(), and v. 01043 { 01044 if (image_list.size() == 0) { 01045 return 0; 01046 } 01047 01048 EMData *image0 = image_list[0]; 01049 int image0_nx = image0->get_xsize(); 01050 int image0_ny = image0->get_ysize(); 01051 int image0_nz = image0->get_zsize(); 01052 size_t size = (size_t)image0_nx * image0_ny * image0_nz; 01053 01054 EMData *result = new EMData(); 01055 01056 result->set_size(image0_nx, image0_ny, image0_nz); 01057 01058 float *dest = result->get_data(); 01059 int nitems = static_cast < int >(image_list.size()); 01060 float *srt = new float[nitems]; 01061 float **src = new float *[nitems]; 01062 01063 for (int i = 0; i < nitems; i++) { 01064 src[i] = image_list[i]->get_data(); 01065 } 01066 01067 for (size_t i = 0; i < size; ++i) { 01068 for (int j = 0; j < nitems; j++) { 01069 srt[j] = src[j][i]; 01070 } 01071 01072 for (int j = 0; j < nitems; j++) { 01073 for (int k = j + 1; k < nitems; k++) { 01074 if (srt[j] < srt[k]) { 01075 float v = srt[j]; 01076 srt[j] = srt[k]; 01077 srt[k] = v; 01078 } 01079 } 01080 } 01081 01082 int l = nitems / 2; 01083 if (nitems < 3) { 01084 dest[i] = srt[l]; 01085 } 01086 else { 01087 dest[i] = (srt[l] + srt[l + 1] + srt[l - 1]) / 3.0f; 01088 } 01089 } 01090 01091 if( srt ) 01092 { 01093 delete[]srt; 01094 srt = 0; 01095 } 01096 if( src ) 01097 { 01098 delete[]src; 01099 src = 0; 01100 } 01101 01102 result->update(); 01103 01104 return result; 01105 }
|
|
Works for regions that are outside the image data dimension area. The only function that calls this is in xplorio.cpp - that function throws if the region is invalid. Definition at line 1198 of file emutil.cpp. References Assert, data, exclude_numbers_io(), get_region_dims(), jump_lines(), jump_lines_by_items(), nx, ny, EMAN::Region::origin, process_lines_io(), and process_numbers_io(). 01202 { 01203 Assert(data != 0); 01204 Assert(file != 0); 01205 Assert(rw_mode == ImageIO::READ_ONLY || 01206 rw_mode == ImageIO::READ_WRITE || 01207 rw_mode == ImageIO::WRITE_ONLY); 01208 01209 int xlen = 0, ylen = 0, zlen = 0; 01210 get_region_dims(area, nx, &xlen, ny, &ylen, nz, &zlen); 01211 01212 int x0 = 0; 01213 int y0 = 0; 01214 int z0 = 0; 01215 01216 if (area) { 01217 x0 = (int)area->origin[0]; 01218 y0 = (int)area->origin[1]; 01219 z0 = (int)area->origin[2]; 01220 } 01221 01222 int nlines_per_sec = (nx *ny) / nitems_per_line; 01223 int nitems_last_line = (nx * ny) % nitems_per_line; 01224 if (nitems_last_line != 0) { 01225 nlines_per_sec++; 01226 } 01227 01228 if (has_index_line) { 01229 nlines_per_sec++; 01230 } 01231 01232 if (z0 > 0) { 01233 jump_lines(file, z0 * nlines_per_sec); 01234 } 01235 01236 01237 int nlines_pre_sec = (y0 * nx + x0) / nitems_per_line; 01238 int gap_nitems = nx - xlen; 01239 int ti = 0; 01240 int rlines = 0; 01241 01242 for (int k = 0; k < zlen; k++) { 01243 EMUtil::jump_lines(file, nlines_pre_sec+1); 01244 01245 int head_nitems = (y0 * nx + x0) % nitems_per_line; 01246 int tail_nitems = 0; 01247 bool is_head_read = false; 01248 01249 for (int j = 0; j < ylen; j++) { 01250 01251 if (head_nitems > 0 && !is_head_read) { 01252 EMUtil::process_numbers_io(file, rw_mode, nitems_per_line, mode_size, 01253 nitems_per_line-head_nitems, 01254 nitems_per_line-1, data, &ti, outformat); 01255 rlines++; 01256 } 01257 01258 EMUtil::process_lines_io(file, rw_mode, nitems_per_line, 01259 mode_size, (xlen - head_nitems), 01260 data, &ti, outformat); 01261 01262 rlines += ((xlen - head_nitems)/nitems_per_line); 01263 01264 tail_nitems = (xlen - head_nitems) % nitems_per_line; 01265 01266 if ((gap_nitems + tail_nitems) > 0) { 01267 head_nitems = nitems_per_line - 01268 (gap_nitems + tail_nitems) % nitems_per_line; 01269 } 01270 else { 01271 head_nitems = 0; 01272 } 01273 01274 is_head_read = false; 01275 01276 if (tail_nitems > 0) { 01277 if ((gap_nitems < (nitems_per_line-tail_nitems)) && 01278 (j != (ylen-1))) { 01279 EMUtil::exclude_numbers_io(file, rw_mode, nitems_per_line, 01280 mode_size, tail_nitems, 01281 tail_nitems+gap_nitems-1, data, &ti, outformat); 01282 is_head_read = true; 01283 rlines++; 01284 } 01285 else { 01286 EMUtil::process_numbers_io(file, rw_mode, nitems_per_line, mode_size, 01287 0, tail_nitems-1, data, &ti, outformat); 01288 rlines++; 01289 } 01290 } 01291 01292 if (gap_nitems > (nitems_per_line-tail_nitems)) { 01293 int gap_nlines = (gap_nitems - (nitems_per_line-tail_nitems)) / 01294 nitems_per_line; 01295 if (gap_nlines > 0 && j != (ylen-1)) { 01296 EMUtil::jump_lines(file, gap_nlines); 01297 } 01298 } 01299 } 01300 01301 int ytail_nitems = (ny-ylen-y0) * nx + (nx-xlen-x0) - (nitems_per_line-tail_nitems); 01302 EMUtil::jump_lines_by_items(file, ytail_nitems, nitems_per_line); 01303 } 01304 }
|
|
Definition at line 1445 of file emutil.cpp. References Assert, data, and process_numbers_io(). Referenced by process_ascii_region_io(). 01449 { 01450 Assert(file); 01451 Assert(data); 01452 Assert(p_i); 01453 01454 if (nitems > 0) { 01455 int nlines = nitems / nitems_per_line; 01456 for (int i = 0; i < nlines; i++) { 01457 EMUtil::process_numbers_io(file, rw_mode, nitems_per_line, mode_size, 0, 01458 nitems_per_line-1, data, p_i, outformat); 01459 } 01460 } 01461 }
|
|
Definition at line 1340 of file emutil.cpp. References Assert, data, and portable_fseek(). Referenced by process_ascii_region_io(), and process_lines_io(). 01343 { 01344 Assert(file); 01345 Assert(start >= 0); 01346 Assert(start <= end); 01347 Assert(end <= nitems_per_line); 01348 Assert(data); 01349 Assert(p_i); 01350 Assert(outformat); 01351 01352 char line[MAXPATHLEN]; 01353 01354 if (rw_mode == ImageIO::READ_ONLY) { 01355 if (!fgets(line, sizeof(line), file)) { 01356 Assert("read xplor file failed"); 01357 } 01358 01359 int nitems_in_line = (int) (strlen(line) / mode_size); 01360 Assert(end <= nitems_in_line); 01361 vector<float> d(nitems_in_line); 01362 char * pline = line; 01363 01364 for (int i = 0; i < nitems_in_line; i++) { 01365 sscanf(pline, "%f", &d[i]); 01366 pline += (int)mode_size; 01367 } 01368 01369 01370 for (int i = start; i <= end; i++) { 01371 data[*p_i] = d[i]; 01372 (*p_i)++; 01373 } 01374 } 01375 else { 01376 portable_fseek(file, mode_size * start, SEEK_CUR); 01377 for (int i = start; i <= end; i++) { 01378 fprintf(file, outformat, data[*p_i]); 01379 (*p_i)++; 01380 } 01381 01382 portable_fseek(file, mode_size * (nitems_per_line - end-1)+1, SEEK_CUR); 01383 } 01384 }
|
|
Process image region IO. It eithers read a region from an image file. Or write a region to an image file. Works for regions that are outside the image data dimension area.(David Woolford, April 23 2009)
Definition at line 789 of file emutil.cpp. References Assert, EMAN::Region::get_ndim(), EMAN::Region::get_origin(), get_region_dims(), EMAN::Region::get_size(), IMAGE_ICOS, ImageReadException, ImageWriteException, nx, ny, portable_fseek(), UnexpectedBehaviorException, EMAN::Vec3d, and EMAN::Vec3i. 00794 { 00795 Assert(vdata != 0); 00796 Assert(file != 0); 00797 Assert(rw_mode == ImageIO::READ_ONLY || 00798 rw_mode == ImageIO::READ_WRITE || 00799 rw_mode == ImageIO::WRITE_ONLY); 00800 00801 if (mode_size == 0) throw UnexpectedBehaviorException("The mode size was 0?"); 00802 00803 unsigned char * cdata = (unsigned char *)vdata; 00804 00805 int dx0 = 0; // data x0 00806 int dy0 = 0; // data y0 00807 int dz0 = 0; // data z0 00808 00809 int fx0 = 0; // file x0 00810 int fy0 = 0; // file y0 00811 int fz0 = nz > 1 ? 0 : image_index; // file z0 00812 00813 00814 int xlen = 0; 00815 int ylen = 0; 00816 int zlen = 0; 00817 get_region_dims(area, nx, &xlen, ny, &ylen, nz, &zlen); 00818 00819 if (area) { // Accommodate for all boundary overlaps of the region 00820 00821 Vec3i origin = area->get_origin(); 00822 00823 00824 fx0 = origin[0]; dx0 = origin[0]; 00825 fy0 = origin[1]; dy0 = origin[1]; 00826 if (nz > 1 && area->get_ndim() > 2) { 00827 fz0 = origin[2]; dz0 = origin[2]; 00828 } 00829 00830 if (need_flip) { 00831 Vec3i size = area->get_size(); 00832 fy0 = ny-(origin[1]+size[1]); 00833 } 00834 00835 if (fx0 < 0) { 00836 dx0 *= -1; 00837 xlen = xlen + fx0; // because there are less reads 00838 fx0 = 0; 00839 }else { 00840 dx0 = 0; 00841 //fx0 *= -1; 00842 } 00843 if (fy0 < 0) { 00844 dy0 *= -1; 00845 ylen = ylen + fy0; // because there are less reads 00846 fy0 = 0; 00847 }else { 00848 if (need_flip){ 00849 dy0*=-1; 00850 } 00851 else dy0 = 0; 00852 //fy0 *= -1; 00853 } 00854 if (fz0 < 0) { 00855 dz0 *= -1; 00856 zlen = zlen + fz0; // because there are less reads 00857 fz0 = 0; 00858 }else { 00859 dz0 = 0; 00860 //fz0 *= -1; 00861 } 00862 00863 if ((fx0 + xlen)> nx) xlen = nx-fx0; 00864 if ((fy0 + ylen)> ny) ylen = ny-fy0; 00865 if ((fz0 + zlen)> nz) zlen = nz-fz0; 00866 if ( xlen <= 0 || ylen <= 0 || zlen <= 0 ) return; // This is fine the region was entirely outside the image 00867 } 00868 00869 if ( xlen <= 0 ) { 00870 cout << "Xlen was too small " << xlen << endl; 00871 return; 00872 } 00873 00874 Vec3i size; 00875 if (area != 0) size = area->get_size(); 00876 else size = Vec3d(nx,ny,nz); 00877 00878 //size_t area_sec_size = xlen * ylen * mode_size; 00879 size_t memory_sec_size = size[0] * size[1] * mode_size; 00880 size_t img_row_size = nx * mode_size + pre_row + post_row; 00881 size_t area_row_size = xlen * mode_size; 00882 size_t memory_row_size = size[0] * mode_size; 00883 00884 if ( area_row_size <= 0 ) { 00885 cout << "Xlen was too small " << xlen << " mode_size " << mode_size << endl; 00886 return; 00887 } 00888 00889 size_t x_pre_gap = fx0 * mode_size; 00890 size_t x_post_gap = (nx - fx0 - xlen) * mode_size; 00891 00892 size_t y_pre_gap = fy0 * img_row_size; 00893 size_t y_post_gap = (ny - fy0 - ylen) * img_row_size; 00894 00895 portable_fseek(file, img_row_size * ny * fz0, SEEK_CUR); 00896 00897 float nxlendata[1]; 00898 int floatsize = (int) sizeof(float); 00899 nxlendata[0] = (float)(nx * floatsize); 00900 00901 for (int k = dz0; k < (dz0+zlen); k++) { 00902 if (y_pre_gap > 0) { 00903 portable_fseek(file, y_pre_gap, SEEK_CUR); 00904 } 00905 //long k2 = k * area_sec_size; 00906 long k2 = k*memory_sec_size; 00907 00908 for (int j = dy0; j < (dy0+ylen); j++) { 00909 if (pre_row > 0) { 00910 if (imgtype == IMAGE_ICOS && rw_mode != ImageIO::READ_ONLY && !area) { 00911 fwrite(nxlendata, floatsize, 1, file); 00912 } 00913 else { 00914 portable_fseek(file, pre_row, SEEK_CUR); 00915 } 00916 } 00917 00918 if (x_pre_gap > 0) { 00919 portable_fseek(file, x_pre_gap, SEEK_CUR); 00920 } 00921 00922 int jj = j; 00923 if (need_flip) { 00924 jj = (dy0+ylen) - 1 - j; 00925 if (dy0 > 0 ) { // region considerations add complications in the flipping scenario (imagic format) 00926 jj += dy0; 00927 } 00928 } 00929 00930 if (rw_mode == ImageIO::READ_ONLY) { 00931 if (fread(&cdata[k2 + jj * memory_row_size+dx0*mode_size], 00932 area_row_size, 1, file) != 1) { 00933 cout << jj << " " << k2 << " " << memory_row_size << " " << dx0 << " " << mode_size << " " << area_row_size << " " << cdata << "done" << endl; 00934 throw ImageReadException("", "incomplete data read"); 00935 } 00936 } 00937 else { 00938 if (fwrite(&cdata[k2 + jj * memory_row_size+dx0*mode_size], 00939 area_row_size, 1, file) != 1) { 00940 throw ImageWriteException("", "incomplete data write"); 00941 } 00942 } 00943 00944 if (x_post_gap > 0) { 00945 portable_fseek(file, x_post_gap, SEEK_CUR); 00946 } 00947 00948 if (post_row > 0) { 00949 if (imgtype == IMAGE_ICOS && rw_mode != ImageIO::READ_ONLY && !area) { 00950 fwrite(nxlendata, floatsize, 1, file); 00951 } 00952 else { 00953 portable_fseek(file, post_row, SEEK_CUR); 00954 } 00955 } 00956 } 00957 00958 if (y_post_gap > 0) { 00959 portable_fseek(file, y_post_gap, SEEK_CUR); 00960 } 00961 } 00962 }
|
|
Definition at line 1006 of file emutil.cpp. References data, dot(), EMAN::EMData::get_data(), EMAN::EMData::get_xsize(), EMAN::EMData::get_ysize(), NullPointerException, nx, ny, EMAN::EMData::set_size(), EMAN::EMData::update(), x, and y. 01007 { 01008 if (!image) { 01009 throw NullPointerException("NULL Image"); 01010 } 01011 01012 EMData *ret = new EMData(); 01013 int nx = image->get_xsize(); 01014 int ny = image->get_ysize(); 01015 01016 if (maxdy <= 1) { 01017 maxdy = ny / 8; 01018 } 01019 01020 ret->set_size(nx, maxdy, 1); 01021 01022 float *data = image->get_data(); 01023 float *ret_data = ret->get_data(); 01024 01025 for (int x = 0; x < nx; x++) { 01026 for (int y = 0; y < maxdy; y++) { 01027 float dot = 0; 01028 for (int yy = maxdy; yy < ny - maxdy; yy++) { 01029 dot += data[x + (yy + y) * nx] * data[x + (yy - y) * nx]; 01030 } 01031 ret_data[x + y * nx] = dot; 01032 } 01033 } 01034 01035 ret->update(); 01036 01037 return ret; 01038 }
|