EMAN2
Public Types | Static Public Member Functions | Static Private Member Functions | List of all members
EMAN::EMUtil Class Reference

#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 ,
  EM_COMPRESSED
}
 Image pixel data type used in EMAN. More...
 
enum  ImageType {
  IMAGE_UNKNOWN , IMAGE_MRC , IMAGE_EER , IMAGE_EER2X ,
  IMAGE_EER4X , IMAGE_SPIDER , IMAGE_SINGLE_SPIDER , IMAGE_IMAGIC ,
  IMAGE_HDF , IMAGE_DM3 , IMAGE_DM4 , 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_SITUS , IMAGE_SER
}
 Image format types. More...
 

Static Public Member Functions

static EMData * vertical_acf (const EMData *image, int maxdy)
 
static ImageType get_image_ext_type (const string &file_ext)
 Get an image's format type from its filename extension. More...
 
static ImageType get_image_type (const string &filename)
 Get an image's format type by processing the first 1K of the image. More...
 
static 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. More...
 
static int get_image_count (const string &filename)
 Get the number of images in an image file. More...
 
static ImageIO * get_imageio (const string &filename, int rw_mode, ImageType image_type=IMAGE_UNKNOWN)
 Get an ImageIO object. More...
 
static void close_imageio (const string &filename, const ImageIO *io)
 Ian: Close ImageIO object. More...
 
static const char * get_imagetype_name (EMUtil::ImageType type)
 Give each image type a meaningful name. More...
 
static const char * get_datatype_string (EMDataType type)
 Give each data type a meaningful name. More...
 
static 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. More...
 
static 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. More...
 
static double mode_size_product (size_t factor, size_t mode_size)
 Return a factor times the mode size, which may be a special value (11111111) meaning one half, needed for MRC packed 8 bit format. More...
 
static 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. More...
 
static 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. More...
 
static void dump_dict (const Dict &dict)
 Dump a Dict object. More...
 
static bool is_same_size (const EMData *image1, const EMData *image2)
 Check whether two EMData images are of the same size. More...
 
static bool is_same_ctf (const EMData *image1, const EMData *image2)
 Check whether two EMData images have the same CTF parameters. More...
 
static bool is_complex_type (EMDataType datatype)
 
static void jump_lines (FILE *file, int nlines)
 
static vector< string > get_euler_names (const string &euler_type)
 
static 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. More...
 
static void getRenderLimits (const Dict &dict, float &rendermin, float &rendermax, int &renderbits)
 Get the min and max pixel value accepted for image nomalization from image attribute dictionary, or return zeroes if not present. More...
 
static void getRenderMinMax (float *data, const int nx, const int ny, float &rendermin, float &rendermax, int &renderbits, const int nz=1)
 Calculate the min and max pixel value accepted for 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. More...
 
static bool cuda_available ()
 
static void * em_malloc (const size_t size)
 
static void * em_calloc (const size_t nmemb, const size_t size)
 
static void * em_realloc (void *data, const size_t new_size)
 
static void em_memset (void *data, const int value, const size_t size)
 
static void em_free (void *data)
 
static void em_memcpy (void *dst, const void *const src, const size_t size)
 

Static Private Member Functions

static ImageType fast_get_image_type (const string &filename, const void *first_block, off_t file_size)
 
static void jump_lines_by_items (FILE *file, int nitems, int nitems_per_line)
 
static 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)
 
static 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)
 
static 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)
 

Detailed Description

Definition at line 84 of file emutil.h.

Member Enumeration Documentation

◆ EMDataType

enum EMAN::EMUtil::EMDataType

Image pixel data type used in EMAN.

EM_U means "EM unsigned". for example, EM_USHORT means EM unsigned short.

Enumerator
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 
EM_COMPRESSED 

Definition at line 91 of file emutil.h.

92 {
93 EM_UNKNOWN,
94 EM_CHAR,
95 EM_UCHAR,
96 EM_SHORT,
97 EM_USHORT,
98 EM_INT,
99 EM_UINT,
100 EM_FLOAT,
101 EM_DOUBLE,
102 EM_SHORT_COMPLEX,
103 EM_USHORT_COMPLEX,
104 EM_FLOAT_COMPLEX,
105 EM_COMPRESSED // compressed
106 };
EMAN::EMUtil::EM_UCHAR
@ EM_UCHAR
Definition: emutil.h:95
EMAN::EMUtil::EM_USHORT_COMPLEX
@ EM_USHORT_COMPLEX
Definition: emutil.h:103
EMAN::EMUtil::EM_COMPRESSED
@ EM_COMPRESSED
Definition: emutil.h:105
EMAN::EMUtil::EM_UNKNOWN
@ EM_UNKNOWN
Definition: emutil.h:93
EMAN::EMUtil::EM_USHORT
@ EM_USHORT
Definition: emutil.h:97
EMAN::EMUtil::EM_FLOAT_COMPLEX
@ EM_FLOAT_COMPLEX
Definition: emutil.h:104
EMAN::EMUtil::EM_SHORT_COMPLEX
@ EM_SHORT_COMPLEX
Definition: emutil.h:102
EMAN::EMUtil::EM_SHORT
@ EM_SHORT
Definition: emutil.h:96

◆ ImageType

enum EMAN::EMUtil::ImageType

Image format types.

Enumerator
IMAGE_UNKNOWN 
IMAGE_MRC 
IMAGE_EER 
IMAGE_EER2X 
IMAGE_EER4X 
IMAGE_SPIDER 
IMAGE_SINGLE_SPIDER 
IMAGE_IMAGIC 
IMAGE_HDF 
IMAGE_DM3 
IMAGE_DM4 
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_SITUS 
IMAGE_SER 

Definition at line 111 of file emutil.h.

112 {
113 IMAGE_UNKNOWN,
114 IMAGE_MRC,
115 IMAGE_EER,
116 IMAGE_EER2X,
117 IMAGE_EER4X,
118 IMAGE_SPIDER,
119 IMAGE_SINGLE_SPIDER,
120 IMAGE_IMAGIC,
121 IMAGE_HDF,
122 IMAGE_DM3,
123 IMAGE_DM4,
124 IMAGE_TIFF,
125 IMAGE_PGM,
126 IMAGE_LST,
127 IMAGE_PIF,
128 IMAGE_VTK,
129 IMAGE_PNG,
130 IMAGE_SAL,
131 IMAGE_ICOS,
132 IMAGE_EMIM,
133 IMAGE_GATAN2,
134 IMAGE_AMIRA,
135 IMAGE_XPLOR,
136 IMAGE_EM,
137 IMAGE_V4L,
138 IMAGE_JPEG,
139 IMAGE_FITS,
140 IMAGE_LSTFAST,
141 IMAGE_DF3,
142 IMAGE_OMAP,
143 IMAGE_SITUS,
144 IMAGE_SER
145 };
EMAN::EMUtil::IMAGE_SINGLE_SPIDER
@ IMAGE_SINGLE_SPIDER
Definition: emutil.h:119
EMAN::EMUtil::IMAGE_XPLOR
@ IMAGE_XPLOR
Definition: emutil.h:135
EMAN::EMUtil::IMAGE_EMIM
@ IMAGE_EMIM
Definition: emutil.h:132
EMAN::EMUtil::IMAGE_IMAGIC
@ IMAGE_IMAGIC
Definition: emutil.h:120
EMAN::EMUtil::IMAGE_LSTFAST
@ IMAGE_LSTFAST
Definition: emutil.h:140
EMAN::EMUtil::IMAGE_UNKNOWN
@ IMAGE_UNKNOWN
Definition: emutil.h:113
EMAN::EMUtil::IMAGE_SITUS
@ IMAGE_SITUS
Definition: emutil.h:143
EMAN::EMUtil::IMAGE_OMAP
@ IMAGE_OMAP
Definition: emutil.h:142
EMAN::EMUtil::IMAGE_EER4X
@ IMAGE_EER4X
Definition: emutil.h:117
EMAN::EMUtil::IMAGE_SPIDER
@ IMAGE_SPIDER
Definition: emutil.h:118
EMAN::EMUtil::IMAGE_EER2X
@ IMAGE_EER2X
Definition: emutil.h:116
EMAN::EMUtil::IMAGE_GATAN2
@ IMAGE_GATAN2
Definition: emutil.h:133
EMAN::EMUtil::IMAGE_JPEG
@ IMAGE_JPEG
Definition: emutil.h:138
EMAN::EMUtil::IMAGE_AMIRA
@ IMAGE_AMIRA
Definition: emutil.h:134
EMAN::EMUtil::IMAGE_FITS
@ IMAGE_FITS
Definition: emutil.h:139
EMAN::EMUtil::IMAGE_TIFF
@ IMAGE_TIFF
Definition: emutil.h:124
EMAN::EMUtil::IMAGE_ICOS
@ IMAGE_ICOS
Definition: emutil.h:131

Member Function Documentation

◆ close_imageio()

void EMUtil::close_imageio ( const string &  filename,
const ImageIO *  io 
)
static

Ian: Close ImageIO object.

Definition at line 720 of file emutil.cpp.

721{
722 //printf("EMUtil::close_imageio\n");
723 #ifdef IMAGEIO_CACHE
724 if (GlobalCache::instance()->contains(filename)) {
725 GlobalCache::instance()->close_imageio(filename);
726 } else {
727 delete io;
728 }
729 #else
730 delete io;
731 #endif
732}

Referenced by get_image_count(), and read_binedimage().

◆ cuda_available()

static bool EMAN::EMUtil::cuda_available ( )
inlinestatic

Definition at line 358 of file emutil.h.

358 {
359//#ifdef EMAN2_USING_CUDA
360// return true;
361//#else
362 return false;
363//#endif
364 }

◆ dump_dict()

void EMUtil::dump_dict ( const Dict &  dict)
static

Dump a Dict object.

Parameters
dictA Dict object.

Definition at line 1204 of file emutil.cpp.

1205{
1206 vector < string > keys = dict.keys();
1207 vector < EMObject > values = dict.values();
1208
1209 for (unsigned int i = 0; i < keys.size(); i++) {
1210 EMObject obj = values[i];
1211
1212 if (! obj.is_null()) {
1213 string val = obj.to_str();
1214
1215 if (keys[i] == "datatype") {
1216 val = get_datatype_string((EMDataType) (int) obj);
1217 }
1218
1219 fprintf(stdout, "%25s\t%s\n", keys[i].c_str(), val.c_str());
1220 }
1221 }
1222}
EMAN::Dict::values
vector< EMObject > values() const
Get a vector containing copies of each of the EMObjects in this dictionary.
Definition: emobject.h:487
EMAN::Dict::keys
vector< string > keys() const
Get a vector containing all of the (string) keys in this dictionary.
Definition: emobject.h:475
EMAN::EMObject
EMObject is a wrapper class for types including int, float, double, etc as defined in ObjectType.
Definition: emobject.h:123
EMAN::EMObject::to_str
string to_str() const
Calls to_str( this->type)
Definition: emobject.cpp:684
EMAN::EMObject::is_null
bool is_null() const
Checks to see if the EMObject is interpretable This basically equates to checking to see if the type ...
Definition: emobject.cpp:679
EMAN::EMUtil::EMDataType
EMDataType
Image pixel data type used in EMAN.
Definition: emutil.h:92
EMAN::EMUtil::get_datatype_string
static const char * get_datatype_string(EMDataType type)
Give each data type a meaningful name.
Definition: emutil.cpp:828

References get_datatype_string(), EMAN::EMObject::is_null(), EMAN::Dict::keys(), EMAN::EMObject::to_str(), and EMAN::Dict::values().

◆ em_calloc()

static void * EMAN::EMUtil::em_calloc ( const size_t  nmemb,
const size_t  size 
)
inlinestatic

Definition at line 370 of file emutil.h.

370 {
371 return calloc(nmemb,size);
372 }

Referenced by EMAN::EMData::setup4slice(), and EMAN::TransformProcessor::transform().

◆ em_free()

static void EMAN::EMUtil::em_free ( void *  data)
inlinestatic

Definition at line 380 of file emutil.h.

380 {
381 free(data);
382 }

Referenced by free_rdata(), and EMAN::EMData::setup4slice().

◆ em_malloc()

static void * EMAN::EMUtil::em_malloc ( const size_t  size)
inlinestatic

Definition at line 366 of file emutil.h.

366 {
367 return malloc(size);
368 }

Referenced by EMAN::EMData::EMData(), and EMAN::EMData::rotate_x().

◆ em_memcpy()

static void EMAN::EMUtil::em_memcpy ( void *  dst,
const void *const  src,
const size_t  size 
)
inlinestatic

Definition at line 384 of file emutil.h.

384 {
385 memcpy(dst,src,size);
386 }

Referenced by EMAN::EMData::clip_inplace(), EMAN::EMData::EMData(), EMAN::EMData::get_top_half(), EMAN::EMData::operator=(), read_binedimage(), EMAN::EMData::rotate_x(), and set_data_pickle().

◆ em_memset()

static void EMAN::EMUtil::em_memset ( void *  data,
const int  value,
const size_t  size 
)
inlinestatic

Definition at line 377 of file emutil.h.

377 {
378 memset(data, value, size);
379 }

Referenced by EMAN::EMData::clip_inplace().

◆ em_realloc()

static void * EMAN::EMUtil::em_realloc ( void *  data,
const size_t  new_size 
)
inlinestatic

Definition at line 374 of file emutil.h.

374 {
375 return realloc(data, new_size);
376 }

◆ exclude_numbers_io()

void EMUtil::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 
)
staticprivate

Definition at line 1554 of file emutil.cpp.

1557{
1558 Assert(file);
1559 Assert(mode_size > 0);
1560 Assert(start >= 0);
1561 Assert(end <= nitems_per_line);
1562 Assert(data);
1563 Assert(p_i);
1564 Assert(outformat);
1565
1566 char line[MAXPATHLEN];
1567
1568 if (rw_mode == ImageIO::READ_ONLY) {
1569
1570 if (!fgets(line, sizeof(line), file)) {
1571 Assert("read xplor file failed");
1572 }
1573
1574 int nitems_in_line = (int) (strlen(line) / mode_size);
1575 Assert(end <= nitems_in_line);
1576
1577 vector<float> d(nitems_in_line);
1578 char *pline = line;
1579
1580 for (int i = 0; i < nitems_in_line; i++) {
1581 sscanf(pline, "%f", &d[i]);
1582 pline = pline + (int)mode_size;
1583 }
1584
1585
1586 for (int i = 0; i < start; i++) {
1587 data[*p_i] = d[i];
1588 (*p_i)++;
1589 }
1590
1591 for (int i = end+1; i < nitems_in_line; i++) {
1592 data[*p_i] = d[i];
1593 (*p_i)++;
1594 }
1595 }
1596 else {
1597 for (int i = 0; i < start; i++) {
1598 fprintf(file, outformat, data[*p_i]);
1599 (*p_i)++;
1600 }
1601
1602 portable_fseek(file, (end-start+1) * mode_size, SEEK_CUR);
1603
1604 for (int i = end+1; i < nitems_per_line; i++) {
1605 fprintf(file, outformat, data[*p_i]);
1606 (*p_i)++;
1607 }
1608 portable_fseek(file, 1, SEEK_CUR);
1609 }
1610}
Assert
#define Assert(s)
Define Assert() function that is effective only when -DDEBUG is used.
Definition: emassert.h:42
portable_fseek
int portable_fseek(FILE *fp, off_t offset, int whence)
Definition: portable_fileio.h:39

References Assert, portable_fseek(), and EMAN::ImageIO::READ_ONLY.

Referenced by process_ascii_region_io().

◆ fast_get_image_type()

EMUtil::ImageType EMUtil::fast_get_image_type ( const string &  filename,
const void *  first_block,
off_t  file_size 
)
staticprivate

Definition at line 229 of file emutil.cpp.

232{
233 ENTERFUNC;
234
235 Assert(filename != "");
236 Assert(first_block != 0);
237 Assert(file_size > 0);
238
239#ifdef ENABLE_V4L2
240 if (filename.compare(0,5,"/dev/")==0) return IMAGE_V4L;
241#endif
242
243 string ext = Util::get_filename_ext(filename);
244
245 if (ext == "") {
246 return IMAGE_UNKNOWN;
247 }
248
249 ImageType image_type = get_image_ext_type(ext);
250
251 switch (image_type) {
252 case IMAGE_MRC:
253 if (MrcIO::is_valid(first_block, file_size)) {
254 return IMAGE_MRC;
255 }
256 break;
257 case IMAGE_EER:
258 return IMAGE_EER;
259 break;
260 case IMAGE_EER2X:
261 return IMAGE_EER2X;
262 break;
263 case IMAGE_EER4X:
264 return IMAGE_EER4X;
265 break;
266 case IMAGE_DM3:
267 if (DM3IO::is_valid(first_block)) {
268 return IMAGE_DM3;
269 }
270 break;
271 case IMAGE_DM4:
272 if (DM4IO::is_valid(first_block)) {
273 return IMAGE_DM4;
274 }
275 break;
276#ifdef USE_HDF5
277 case IMAGE_HDF:
278 if (HdfIO2::is_valid(first_block)) {
279 return IMAGE_HDF;
280 }
281 break;
282#endif
283 case IMAGE_LST:
284 if (LstIO::is_valid(first_block)) {
285 return IMAGE_LST;
286 }
287 break;
288 case IMAGE_LSTFAST:
289 if (LstFastIO::is_valid(first_block)) {
290 return IMAGE_LSTFAST;
291 }
292 break;
293#ifdef USE_TIFF
294 case IMAGE_TIFF:
295 if (TiffIO::is_valid(first_block)) {
296 return IMAGE_TIFF;
297 }
298 break;
299#endif
300 case IMAGE_SPIDER:
301 if (SpiderIO::is_valid(first_block)) {
302 return IMAGE_SPIDER;
303 }
304 break;
305 case IMAGE_SINGLE_SPIDER:
306 if (SingleSpiderIO::is_valid(first_block)) {
307 return IMAGE_SINGLE_SPIDER;
308 }
309 break;
310 case IMAGE_PIF:
311 if (PifIO::is_valid(first_block)) {
312 return IMAGE_PIF;
313 }
314 break;
315#ifdef USE_PNG
316 case IMAGE_PNG:
317 if (PngIO::is_valid(first_block)) {
318 return IMAGE_PNG;
319 }
320 break;
321#endif
322 case IMAGE_VTK:
323 if (VtkIO::is_valid(first_block)) {
324 return IMAGE_VTK;
325 }
326 break;
327 case IMAGE_PGM:
328 if (PgmIO::is_valid(first_block)) {
329 return IMAGE_PGM;
330 }
331 break;
332 case IMAGE_ICOS:
333 if (IcosIO::is_valid(first_block)) {
334 return IMAGE_ICOS;
335 }
336 break;
337 case IMAGE_SAL:
338 if (SalIO::is_valid(first_block)) {
339 return IMAGE_SAL;
340 }
341 break;
342 case IMAGE_AMIRA:
343 if (AmiraIO::is_valid(first_block)) {
344 return IMAGE_AMIRA;
345 }
346 break;
347 case IMAGE_XPLOR:
348 if (XplorIO::is_valid(first_block)) {
349 return IMAGE_XPLOR;
350 }
351 break;
352 case IMAGE_GATAN2:
353 if (Gatan2IO::is_valid(first_block)) {
354 return IMAGE_GATAN2;
355 }
356 break;
357 case IMAGE_EM:
358 if (EmIO::is_valid(first_block, file_size)) {
359 return IMAGE_EM;
360 }
361 break;
362 case IMAGE_DF3:
363 if (EmIO::is_valid(first_block, file_size)) {
364 return IMAGE_DF3;
365 }
366 break;
367 case IMAGE_OMAP:
368 if (OmapIO::is_valid(first_block, file_size)) {
369 return IMAGE_OMAP;
370 }
371 break;
372 case IMAGE_SITUS:
373 if (SitusIO::is_valid(first_block)) {
374 return IMAGE_SITUS;
375 }
376 break;
377 case IMAGE_SER:
378 if (SerIO::is_valid(first_block)) {
379 return IMAGE_SER;
380 }
381 break;
382 case IMAGE_IMAGIC:
383 if (ImagicIO::is_valid(first_block)) {
384 return IMAGE_IMAGIC;
385 }
386 break;
387 default:
388 return IMAGE_UNKNOWN;
389 }
390
391 EXITFUNC;
392
393 return IMAGE_UNKNOWN;
394}
EMAN::AmiraIO::is_valid
static bool is_valid(const void *first_block)
Definition: amiraio.cpp:100
EMAN::DM3IO::is_valid
static bool is_valid(const void *first_block)
Definition: dm3io.cpp:694
EMAN::DM4IO::is_valid
static bool is_valid(const void *first_block)
Definition: dm4io.cpp:811
EMAN::EMUtil::ImageType
ImageType
Image format types.
Definition: emutil.h:112
EMAN::EMUtil::get_image_ext_type
static ImageType get_image_ext_type(const string &file_ext)
Get an image's format type from its filename extension.
Definition: emutil.cpp:58
EMAN::EmIO::is_valid
static bool is_valid(const void *first_block, off_t file_size=0)
Definition: emio.cpp:95
EMAN::Gatan2IO::is_valid
static bool is_valid(const void *first_block)
Definition: gatan2io.cpp:82
EMAN::IcosIO::is_valid
static bool is_valid(const void *first_block)
Definition: icosio.cpp:80
EMAN::ImagicIO::is_valid
static bool is_valid(const void *first_block)
Definition: imagicio.cpp:121
EMAN::LstFastIO::is_valid
static bool is_valid(const void *first_block)
Definition: lstfastio.cpp:111
EMAN::LstIO::is_valid
static bool is_valid(const void *first_block)
Definition: lstio.cpp:110
EMAN::MrcIO::is_valid
static bool is_valid(const void *first_block, off_t file_size=0)
Definition: mrcio.cpp:342
EMAN::OmapIO::is_valid
static bool is_valid(const void *first_block, off_t file_size=0)
Definition: omapio.cpp:236
EMAN::PgmIO::is_valid
static bool is_valid(const void *first_block)
Definition: pgmio.cpp:120
EMAN::PifIO::is_valid
static bool is_valid(const void *first_block)
Definition: pifio.cpp:164
EMAN::SalIO::is_valid
static bool is_valid(const void *first_block)
Definition: salio.cpp:141
EMAN::SerIO::is_valid
static bool is_valid(const void *first_block)
Definition: serio.cpp:94
EMAN::SingleSpiderIO::is_valid
static bool is_valid(const void *first_block)
Definition: sspiderio.cpp:71
EMAN::SitusIO::is_valid
static bool is_valid(const void *first_block)
Definition: situsio.cpp:182
EMAN::SpiderIO::is_valid
static bool is_valid(const void *first_block)
Definition: spiderio.cpp:111
EMAN::Util::get_filename_ext
static string get_filename_ext(const string &filename)
Get a filename's extension.
Definition: util.cpp:526
EMAN::VtkIO::is_valid
static bool is_valid(const void *first_block)
Definition: vtkio.cpp:160
EMAN::XplorIO::is_valid
static bool is_valid(const void *first_block)
Definition: xplorio.cpp:148
ENTERFUNC
#define ENTERFUNC
Definition: log.h:48
EXITFUNC
#define EXITFUNC
Definition: log.h:49

References Assert, ENTERFUNC, EXITFUNC, EMAN::Util::get_filename_ext(), get_image_ext_type(), IMAGE_AMIRA, IMAGE_DF3, IMAGE_DM3, IMAGE_DM4, IMAGE_EER, IMAGE_EER2X, IMAGE_EER4X, 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_SER, IMAGE_SINGLE_SPIDER, IMAGE_SITUS, IMAGE_SPIDER, IMAGE_TIFF, IMAGE_UNKNOWN, IMAGE_V4L, IMAGE_VTK, IMAGE_XPLOR, EMAN::AmiraIO::is_valid(), EMAN::DM3IO::is_valid(), EMAN::DM4IO::is_valid(), EMAN::Gatan2IO::is_valid(), EMAN::IcosIO::is_valid(), EMAN::ImagicIO::is_valid(), EMAN::LstFastIO::is_valid(), EMAN::LstIO::is_valid(), EMAN::PgmIO::is_valid(), EMAN::PifIO::is_valid(), EMAN::SalIO::is_valid(), EMAN::SerIO::is_valid(), EMAN::SitusIO::is_valid(), EMAN::SpiderIO::is_valid(), EMAN::SingleSpiderIO::is_valid(), EMAN::VtkIO::is_valid(), EMAN::XplorIO::is_valid(), EMAN::EmIO::is_valid(), EMAN::MrcIO::is_valid(), and EMAN::OmapIO::is_valid().

Referenced by get_image_type().

◆ get_all_attributes()

vector< EMObject > EMUtil::get_all_attributes ( const string &  file_name,
const string &  attr_name 
)
static

Get an attribute from a stack of image, returned as a vector.

Parameters
file_namethe image file name
attr_nameThe header attribute name.
Returns
the vector of attribute value
Exceptions
NotExistingObjectExceptionwhen access an non-existing attribute
InvalidCallExceptionwhen call this function for a non-stack image

Definition at line 1674 of file emutil.cpp.

1675{
1676 vector<EMObject> v;
1677
1678 Assert(file_name != "");
1679 Assert(attr_name != "");
1680
1681 auto vpImg = EMData::read_images(file_name, vector<int>(), EMUtil::IMAGE_UNKNOWN, true);
1682
1683 for (auto iter = vpImg.begin(); iter!=vpImg.end(); ++iter)
1684 v.push_back((*iter)->get_attr_default(attr_name));
1685
1686 return v;
1687}
read_images
static vector< std::shared_ptr< EMData > > read_images(const string &filename, vector< int > img_indices=vector< int >(), EMUtil::ImageType imgtype=EMUtil::IMAGE_UNKNOWN, bool header_only=false)
Read a set of images from file specified by 'filename'.

References Assert, IMAGE_UNKNOWN, and read_images().

◆ get_datatype_string()

const char * EMUtil::get_datatype_string ( EMDataType  type)
static

Give each data type a meaningful name.

Parameters
typethe EMDataType
Returns
a name for that data type

Definition at line 828 of file emutil.cpp.

829{
830 switch (type) {
831 case EM_CHAR:
832 return "CHAR";
833 case EM_UCHAR:
834 return "UNSIGNED CHAR";
835 case EM_SHORT:
836 return "SHORT";
837 case EM_USHORT:
838 return "UNSIGNED SHORT";
839 case EM_INT:
840 return "INT";
841 case EM_UINT:
842 return "UNSIGNED INT";
843 case EM_FLOAT:
844 return "FLOAT";
845 case EM_DOUBLE:
846 return "DOUBLE";
847 case EM_SHORT_COMPLEX:
848 return "SHORT_COMPLEX";
849 case EM_USHORT_COMPLEX:
850 return "USHORT_COMPLEX";
851 case EM_FLOAT_COMPLEX:
852 return "FLOAT_COMPLEX";
853 case EM_UNKNOWN:
854 return "UNKNOWN";
855 }
856
857 return "UNKNOWN";
858}

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

◆ get_euler_names()

vector< string > EMUtil::get_euler_names ( const string &  euler_type)
static

Definition at line 1631 of file emutil.cpp.

1632{
1633 vector<string> v;
1634 string b = "euler_";
1635
1636 if (euler_type == "EMAN") {
1637 v.push_back(b + "alt");
1638 v.push_back(b + "az");
1639 v.push_back(b + "phi");
1640 }
1641 else if (euler_type == "MRC") {
1642 v.push_back(b + "theta");
1643 v.push_back(b + "phi");
1644 v.push_back(b + "omega");
1645 }
1646 else if (euler_type == "IMAGIC") {
1647 v.push_back(b + "alpha");
1648 v.push_back(b + "beta");
1649 v.push_back(b + "gamma");
1650 }
1651 else if (euler_type == "SPIDER") {
1652 v.push_back(b + "phi");
1653 v.push_back(b + "theta");
1654 v.push_back(b + "gamma");
1655 }
1656 else if (euler_type == "SPIN" ||
1657 euler_type == "SGIROT") {
1658 v.push_back(b + "q");
1659 v.push_back(b + "n1");
1660 v.push_back(b + "n2");
1661 v.push_back(b + "n3");
1662 }
1663
1664 else if (euler_type == "QUATERNION") {
1665 v.push_back(b + "e0");
1666 v.push_back(b + "e1");
1667 v.push_back(b + "e2");
1668 v.push_back(b + "e3");
1669 }
1670
1671 return v;
1672}

◆ get_image_count()

int EMUtil::get_image_count ( const string &  filename)
static

Get the number of images in an image file.

Parameters
filenameImage file name.
Returns
Number of images in the given file.

Definition at line 534 of file emutil.cpp.

535{
536 ENTERFUNC;
537
538 Assert(filename != "");
539
540 int nimg = 0;
541
542 ImageIO *imageio = get_imageio(filename, ImageIO::READ_ONLY);
543 //printf("%p\n",imageio);
544
545 if (imageio) {
546 nimg = imageio->get_nimg();
547 }
548
549 EMUtil::close_imageio(filename, imageio);
550
551 imageio = NULL;
552
553 EXITFUNC;
554
555 return nimg;
556}
EMAN::EMUtil::close_imageio
static void close_imageio(const string &filename, const ImageIO *io)
Ian: Close ImageIO object.
Definition: emutil.cpp:720
EMAN::EMUtil::get_imageio
static ImageIO * get_imageio(const string &filename, int rw_mode, ImageType image_type=IMAGE_UNKNOWN)
Get an ImageIO object.
Definition: emutil.cpp:558
EMAN::ImageIO
ImageIO classes are designed for reading/writing various electron micrography image formats,...
Definition: imageio.h:127
EMAN::ImageIO::get_nimg
virtual int get_nimg()
Return the number of images in this image file.
Definition: imageio.cpp:176

References Assert, close_imageio(), ENTERFUNC, EXITFUNC, get_imageio(), EMAN::ImageIO::get_nimg(), and EMAN::ImageIO::READ_ONLY.

◆ get_image_ext_type()

EMUtil::ImageType EMUtil::get_image_ext_type ( const string &  file_ext)
static

Get an image's format type from its filename extension.

Parameters
file_extFile extension.
Returns
image format type.

Definition at line 58 of file emutil.cpp.

59{
60 ENTERFUNC;
61
62 static bool initialized = false;
63 static map < string, ImageType > imagetypes;
64
65 if (!initialized) {
66 imagetypes["rec"] = IMAGE_MRC;
67 imagetypes["mrc"] = IMAGE_MRC;
68 imagetypes["MRC"] = IMAGE_MRC;
69 imagetypes["ali"] = IMAGE_MRC;
70 imagetypes["st"] = IMAGE_MRC; // IMOD stack file
71
72 imagetypes["mrcs"] = IMAGE_MRC;
73 imagetypes["MRCS"] = IMAGE_MRC;
74
75 imagetypes["raw"] = IMAGE_MRC;
76 imagetypes["RAW"] = IMAGE_MRC;
77
78 imagetypes["tnf"] = IMAGE_MRC;
79 imagetypes["TNF"] = IMAGE_MRC;
80
81 imagetypes["ccp4"] = IMAGE_MRC;
82 imagetypes["map"] = IMAGE_MRC;
83
84 imagetypes["dm3"] = IMAGE_DM3;
85 imagetypes["DM3"] = IMAGE_DM3;
86
87 imagetypes["dm4"] = IMAGE_DM4;
88 imagetypes["DM4"] = IMAGE_DM4;
89
90 imagetypes["dat"] = IMAGE_SPIDER;
91 imagetypes["spi"] = IMAGE_SPIDER;
92 imagetypes["SPI"] = IMAGE_SPIDER;
93 imagetypes["dat"] = IMAGE_SPIDER;
94 imagetypes["DAT"] = IMAGE_SPIDER;
95
96 imagetypes["spider"] = IMAGE_SPIDER;
97 imagetypes["SPIDER"] = IMAGE_SPIDER;
98
99 imagetypes["spidersingle"] = IMAGE_SINGLE_SPIDER;
100 imagetypes["SPIDERSINGLE"] = IMAGE_SINGLE_SPIDER;
101
102 imagetypes["singlespider"] = IMAGE_SINGLE_SPIDER;
103 imagetypes["SINGLESPIDER"] = IMAGE_SINGLE_SPIDER;
104
105 imagetypes["img"] = IMAGE_IMAGIC;
106 imagetypes["IMG"] = IMAGE_IMAGIC;
107
108 imagetypes["hed"] = IMAGE_IMAGIC;
109 imagetypes["HED"] = IMAGE_IMAGIC;
110
111 imagetypes["imagic"] = IMAGE_IMAGIC;
112 imagetypes["IMAGIC"] = IMAGE_IMAGIC;
113
114 imagetypes["pgm"] = IMAGE_PGM;
115 imagetypes["PGM"] = IMAGE_PGM;
116
117 imagetypes["lst"] = IMAGE_LST;
118 imagetypes["LST"] = IMAGE_LST;
119
120 imagetypes["lsx"] = IMAGE_LSTFAST; // but .lst or another extension would also be ok
121 imagetypes["LSX"] = IMAGE_LSTFAST;
122
123 imagetypes["pif"] = IMAGE_PIF;
124 imagetypes["PIF"] = IMAGE_PIF;
125
126 imagetypes["png"] = IMAGE_PNG;
127 imagetypes["PNG"] = IMAGE_PNG;
128
129 imagetypes["h5"] = IMAGE_HDF;
130 imagetypes["H5"] = IMAGE_HDF;
131
132 imagetypes["hd5"] = IMAGE_HDF;
133 imagetypes["HD5"] = IMAGE_HDF;
134
135 imagetypes["hdf"] = IMAGE_HDF;
136 imagetypes["HDF"] = IMAGE_HDF;
137
138 imagetypes["tif"] = IMAGE_TIFF;
139 imagetypes["TIF"] = IMAGE_TIFF;
140
141 imagetypes["tiff"] = IMAGE_TIFF;
142 imagetypes["TIFF"] = IMAGE_TIFF;
143
144 imagetypes["fts"] = IMAGE_FITS;
145 imagetypes["FTS"] = IMAGE_FITS;
146
147 imagetypes["vtk"] = IMAGE_VTK;
148 imagetypes["VTK"] = IMAGE_VTK;
149
150 imagetypes["hdr"] = IMAGE_SAL;
151 imagetypes["HDR"] = IMAGE_SAL;
152
153 imagetypes["sal"] = IMAGE_SAL;
154 imagetypes["SAL"] = IMAGE_SAL;
155
156 imagetypes["map"] = IMAGE_ICOS;
157 imagetypes["MAP"] = IMAGE_ICOS;
158
159 imagetypes["icos"] = IMAGE_ICOS;
160 imagetypes["ICOS"] = IMAGE_ICOS;
161
162 imagetypes["am"] = IMAGE_AMIRA;
163 imagetypes["AM"] = IMAGE_AMIRA;
164
165 imagetypes["amira"] = IMAGE_AMIRA;
166 imagetypes["AMIRA"] = IMAGE_AMIRA;
167
168 imagetypes["emim"] = IMAGE_EMIM;
169 imagetypes["EMIM"] = IMAGE_EMIM;
170
171 imagetypes["xplor"] = IMAGE_XPLOR;
172 imagetypes["XPLOR"] = IMAGE_XPLOR;
173
174 imagetypes["em"] = IMAGE_EM;
175 imagetypes["EM"] = IMAGE_EM;
176
177 imagetypes["dm2"] = IMAGE_GATAN2;
178 imagetypes["DM2"] = IMAGE_GATAN2;
179
180 imagetypes["v4l"] = IMAGE_V4L;
181 imagetypes["V4L"] = IMAGE_V4L;
182
183 imagetypes["jpg"] = IMAGE_JPEG;
184 imagetypes["JPG"] = IMAGE_JPEG;
185 imagetypes["jpeg"] = IMAGE_JPEG;
186 imagetypes["JPEG"] = IMAGE_JPEG;
187
188 imagetypes["df3"] = IMAGE_DF3;
189 imagetypes["DF3"] = IMAGE_DF3;
190
191 imagetypes["Omap"] = IMAGE_OMAP;
192 imagetypes["omap"] = IMAGE_OMAP;
193 imagetypes["OMAP"] = IMAGE_OMAP;
194 imagetypes["BRIX"] = IMAGE_OMAP;
195 imagetypes["brix"] = IMAGE_OMAP;
196 imagetypes["DSN6"] = IMAGE_OMAP;
197
198 imagetypes["situs"] = IMAGE_SITUS;
199 imagetypes["SITUS"] = IMAGE_SITUS;
200
201 imagetypes["ser"] = IMAGE_SER;
202 imagetypes["SER"] = IMAGE_SER;
203
204 imagetypes["eer"] = IMAGE_EER;
205// imagetypes["eer"] = IMAGE_EER2X;
206// imagetypes["eer"] = IMAGE_EER4X;
207
208 initialized = true;
209 }
210
211 ImageType result = IMAGE_UNKNOWN;
212
213 if (imagetypes.find(file_ext) != imagetypes.end()) {
214 result = imagetypes[file_ext];
215 }
216
217 EXITFUNC;
218
219 return result;
220}

References ENTERFUNC, EXITFUNC, IMAGE_AMIRA, IMAGE_DF3, IMAGE_DM3, IMAGE_DM4, IMAGE_EER, 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_SER, IMAGE_SINGLE_SPIDER, IMAGE_SITUS, IMAGE_SPIDER, IMAGE_TIFF, IMAGE_UNKNOWN, IMAGE_V4L, IMAGE_VTK, and IMAGE_XPLOR.

Referenced by fast_get_image_type(), and is_valid_filename().

◆ get_image_type()

EMUtil::ImageType EMUtil::get_image_type ( const string &  filename)
static

Get an image's format type by processing the first 1K of the image.

Parameters
filenameImage file name.
Returns
image format type.

Definition at line 396 of file emutil.cpp.

397{
398 ENTERFUNC;
399
400 Assert(in_filename != "");
401
402#ifdef ENABLE_V4L2
403 if (in_filename.compare(0,5,"/dev/")==0) return IMAGE_V4L;
404#endif
405
406 string filename = in_filename;
407
408 string old_ext = Util::get_filename_ext(filename);
409
410 if (old_ext == ImagicIO::IMG_EXT) {
411 filename = Util::change_filename_ext(filename, ImagicIO::HED_EXT);
412 }
413 else if (old_ext == "hdf") {
414 return IMAGE_HDF;
415 }
416
417 FILE *in = fopen(filename.c_str(), "rb");
418
419 if (! in) {
420 throw FileAccessException(filename);
421 }
422
423 char first_block[1024];
424 size_t n = fread(first_block, 1, 1024, in);
425 portable_fseek(in, 0, SEEK_END);
426 off_t file_size = portable_ftell(in);
427
428 if (n == 0) {
429// This produces annoying console messages
430// LOGERR("file '%s' is an empty file", filename.c_str());
431 fclose(in);
432 return IMAGE_UNKNOWN;
433 }
434
435 fclose(in);
436
437 ImageType image_type = fast_get_image_type(filename, first_block, file_size);
438
439 if (image_type != IMAGE_UNKNOWN) {
440 return image_type;
441 }
442
443 if (SpiderIO::is_valid(first_block)) {
444 image_type = IMAGE_SPIDER;
445 }
446 else if (SingleSpiderIO::is_valid(first_block)) {
447 image_type = IMAGE_SINGLE_SPIDER;
448 }
449 else if (MrcIO::is_valid(first_block, file_size)) {
450 image_type = IMAGE_MRC;
451 }
452 else if (DM3IO::is_valid(first_block)) {
453 image_type = IMAGE_DM3;
454 }
455 else if (DM4IO::is_valid(first_block)) {
456 image_type = IMAGE_DM4;
457 }
458#ifdef USE_HDF5
459 else if (HdfIO2::is_valid(first_block)) {
460 image_type = IMAGE_HDF;
461 }
462#endif
463 else if (LstIO::is_valid(first_block)) {
464 image_type = IMAGE_LST;
465 }
466 else if (LstFastIO::is_valid(first_block)) {
467 image_type = IMAGE_LSTFAST;
468 }
469#ifdef USE_TIFF
470 else if (TiffIO::is_valid(first_block)) {
471 image_type = IMAGE_TIFF;
472 }
473#endif
474 else if (PifIO::is_valid(first_block)) {
475 image_type = IMAGE_PIF;
476 }
477#ifdef USE_PNG
478 else if (PngIO::is_valid(first_block)) {
479 image_type = IMAGE_PNG;
480 }
481#endif
482 else if (VtkIO::is_valid(first_block)) {
483 image_type = IMAGE_VTK;
484 }
485 else if (PgmIO::is_valid(first_block)) {
486 image_type = IMAGE_PGM;
487 }
488 else if (IcosIO::is_valid(first_block)) {
489 image_type = IMAGE_ICOS;
490 }
491 else if (SalIO::is_valid(first_block)) {
492 image_type = IMAGE_SAL;
493 }
494 else if (AmiraIO::is_valid(first_block)) {
495 image_type = IMAGE_AMIRA;
496 }
497 else if (XplorIO::is_valid(first_block)) {
498 image_type = IMAGE_XPLOR;
499 }
500 else if (Gatan2IO::is_valid(first_block)) {
501 image_type = IMAGE_GATAN2;
502 }
503 else if (FitsIO::is_valid(first_block)) {
504 image_type = IMAGE_FITS;
505 }
506 else if (EmIO::is_valid(first_block, file_size)) {
507 image_type = IMAGE_EM;
508 }
509 else if(OmapIO::is_valid(first_block, file_size)) {
510 image_type = IMAGE_OMAP;
511 }
512 else if(SitusIO::is_valid(first_block)) {
513 image_type = IMAGE_SITUS;
514 }
515 else if(SerIO::is_valid(first_block)) {
516 image_type = IMAGE_SER;
517 }
518 else if (ImagicIO::is_valid(first_block)) {
519 image_type = IMAGE_IMAGIC;
520 }
521 else if (Df3IO::is_valid(first_block)) {
522 image_type = IMAGE_DF3;
523 }
524 else {
525 // LOGERR("I don't know this image's type: '%s'", filename.c_str());
526 throw ImageFormatException("invalid image type");
527 }
528
529 EXITFUNC;
530
531 return image_type;
532}
EMAN::Df3IO::is_valid
static bool is_valid(const void *first_block, off_t file_size=0)
Definition: df3io.cpp:264
EMAN::EMUtil::fast_get_image_type
static ImageType fast_get_image_type(const string &filename, const void *first_block, off_t file_size)
Definition: emutil.cpp:229
EMAN::FitsIO::is_valid
static bool is_valid(const void *first_block, off_t file_size=0)
Definition: fitsio.cpp:77
EMAN::ImagicIO::HED_EXT
static const char * HED_EXT
Definition: imagicio.h:68
EMAN::ImagicIO::IMG_EXT
static const char * IMG_EXT
Definition: imagicio.h:69
EMAN::Util::change_filename_ext
static string change_filename_ext(const string &old_filename, const string &new_ext)
Change a file's extension and return the new filename.
Definition: util.cpp:485
ImageFormatException
#define ImageFormatException(desc)
Definition: exception.h:147
FileAccessException
#define FileAccessException(filename)
Definition: exception.h:187
portable_ftell
off_t portable_ftell(FILE *fp)
Definition: portable_fileio.h:52

References Assert, EMAN::Util::change_filename_ext(), ENTERFUNC, EXITFUNC, fast_get_image_type(), FileAccessException, EMAN::Util::get_filename_ext(), EMAN::ImagicIO::HED_EXT, IMAGE_AMIRA, IMAGE_DF3, IMAGE_DM3, IMAGE_DM4, IMAGE_EM, IMAGE_FITS, 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_SER, IMAGE_SINGLE_SPIDER, IMAGE_SITUS, IMAGE_SPIDER, IMAGE_TIFF, IMAGE_UNKNOWN, IMAGE_V4L, IMAGE_VTK, IMAGE_XPLOR, ImageFormatException, EMAN::ImagicIO::IMG_EXT, EMAN::AmiraIO::is_valid(), EMAN::DM3IO::is_valid(), EMAN::DM4IO::is_valid(), EMAN::Gatan2IO::is_valid(), EMAN::IcosIO::is_valid(), EMAN::ImagicIO::is_valid(), EMAN::LstFastIO::is_valid(), EMAN::LstIO::is_valid(), EMAN::PgmIO::is_valid(), EMAN::PifIO::is_valid(), EMAN::SalIO::is_valid(), EMAN::SerIO::is_valid(), EMAN::SitusIO::is_valid(), EMAN::SpiderIO::is_valid(), EMAN::SingleSpiderIO::is_valid(), EMAN::VtkIO::is_valid(), EMAN::XplorIO::is_valid(), EMAN::Df3IO::is_valid(), EMAN::EmIO::is_valid(), EMAN::FitsIO::is_valid(), EMAN::MrcIO::is_valid(), EMAN::OmapIO::is_valid(), portable_fseek(), and portable_ftell().

Referenced by get_imageio().

◆ get_imageio()

ImageIO * EMUtil::get_imageio ( const string &  filename,
int  rw_mode,
ImageType  image_type = IMAGE_UNKNOWN 
)
static

Get an ImageIO object.

It may be a newly created object. Or an object stored in the cache.

Parameters
filenameImage file name.
rw_modeImageIO read/write mode.
image_typeImage format type.
Returns
An ImageIO object.

Definition at line 558 of file emutil.cpp.

560{
561 ENTERFUNC;
562
563 // printf("EMUtil::get_imageio\n");
564
565 Assert(filename != "");
566 Assert(rw == ImageIO::READ_ONLY ||
567 rw == ImageIO::READ_WRITE ||
568 rw == ImageIO::WRITE_ONLY);
569
570 ImageIO *imageio = 0;
571 int persist = 0;
572
573 #ifdef IMAGEIO_CACHE
574 imageio = GlobalCache::instance()->get_imageio(filename, rw);
575 if (imageio) {
576 return imageio;
577 }
578 #endif
579
580 ImageIO::IOMode rw_mode = static_cast < ImageIO::IOMode > (rw);
581
582 if (image_type == IMAGE_UNKNOWN) {
583 image_type = get_image_type(filename);
584 }
585
586 if (image_type == IMAGE_UNKNOWN) {
587 if(rw == ImageIO::WRITE_ONLY || rw == ImageIO::READ_WRITE) {
588 throw ImageFormatException("writing to this image format not supported.");
589 }
590 }
591
592 switch (image_type) {
593#ifdef ENABLE_V4L2
594 case IMAGE_V4L:
595 imageio = new V4L2IO(filename, rw_mode);
596 break;
597#endif
598 case IMAGE_MRC:
599 imageio = new MrcIO(filename, rw_mode);
600 break;
601 case IMAGE_EER:
602 imageio = new EerIO(filename, rw_mode, decoder0x);
603 break;
604 case IMAGE_EER2X:
605 imageio = new EerIO(filename, rw_mode, decoder1x);
606 break;
607 case IMAGE_EER4X:
608 imageio = new EerIO(filename, rw_mode, decoder2x);
609 break;
610 case IMAGE_IMAGIC:
611 imageio = new ImagicIO2(filename, rw_mode);
612 if (rw_mode==ImageIO::READ_ONLY && ((ImagicIO2 *)imageio)->init_test()==-1 ) {
613 delete imageio;
614 imageio = new ImagicIO(filename, rw_mode);
615 }
616 break;
617 case IMAGE_DM3:
618 imageio = new DM3IO(filename, rw_mode);
619 break;
620 case IMAGE_DM4:
621 imageio = new DM4IO(filename, rw_mode);
622 break;
623#ifdef USE_TIFF
624 case IMAGE_TIFF:
625 imageio = new TiffIO(filename, rw_mode);
626 break;
627#endif
628#ifdef USE_HDF5
629 case IMAGE_HDF:
630 persist = 30;
631 if (rw_mode != ImageIO::READ_ONLY) {
632 persist = 3;
633 }
634 imageio = new HdfIO2(filename, rw_mode);
635 if (((HdfIO2 *)imageio)->init_test()==-1) {
636 delete imageio;
637 imageio = new HdfIO(filename, rw_mode);
638 }
639 break;
640#endif //USE_HDF5
641 case IMAGE_LST:
642 imageio = new LstIO(filename, rw_mode);
643 break;
644 case IMAGE_LSTFAST:
645 imageio = new LstFastIO(filename, rw_mode);
646 break;
647 case IMAGE_PIF:
648 imageio = new PifIO(filename, rw_mode);
649 break;
650 case IMAGE_VTK:
651 imageio = new VtkIO(filename, rw_mode);
652 break;
653 case IMAGE_SPIDER:
654 imageio = new SpiderIO(filename, rw_mode);
655 break;
656 case IMAGE_SINGLE_SPIDER:
657 imageio = new SingleSpiderIO(filename, rw_mode);
658 break;
659 case IMAGE_PGM:
660 imageio = new PgmIO(filename, rw_mode);
661 break;
662#ifdef USE_JPEG
663 case IMAGE_JPEG:
664 imageio = new JpegIO(filename,rw_mode);
665 break;
666#endif
667 case IMAGE_ICOS:
668 imageio = new IcosIO(filename, rw_mode);
669 break;
670#ifdef USE_PNG
671 case IMAGE_PNG:
672 imageio = new PngIO(filename, rw_mode);
673 break;
674#endif
675 case IMAGE_SAL:
676 imageio = new SalIO(filename, rw_mode);
677 break;
678 case IMAGE_AMIRA:
679 imageio = new AmiraIO(filename, rw_mode);
680 break;
681 case IMAGE_GATAN2:
682 imageio = new Gatan2IO(filename, rw_mode);
683 break;
684 case IMAGE_EM:
685 imageio = new EmIO(filename, rw_mode);
686 break;
687 case IMAGE_XPLOR:
688 imageio = new XplorIO(filename, rw_mode);
689 break;
690 case IMAGE_FITS:
691 imageio = new FitsIO(filename, rw_mode);
692 break;
693 case IMAGE_DF3:
694 imageio = new Df3IO(filename, rw_mode);
695 break;
696 case IMAGE_OMAP:
697 imageio = new OmapIO(filename, rw_mode);
698 break;
699 case IMAGE_SITUS:
700 imageio = new SitusIO(filename, rw_mode);
701 break;
702 case IMAGE_SER:
703 imageio = new SerIO(filename, rw_mode);
704 break;
705 default:
706 break;
707 }
708
709 #ifdef IMAGEIO_CACHE
710 if (persist > 0) {
711 GlobalCache::instance()->add_imageio(filename, rw, persist, imageio);
712 }
713 #endif
714
715 EXITFUNC;
716
717 return imageio;
718}
EMAN::AmiraIO
Amira file = ASCII header + binary data.
Definition: amiraio.h:49
EMAN::DM3IO
Gatan DM3 file is a hierarchical binary image format.
Definition: dm3io.h:243
EMAN::DM4IO
Gatan DM$ was introduced with the GMS 2.0 release.
Definition: dm4io.h:250
EMAN::EMUtil::get_image_type
static ImageType get_image_type(const string &filename)
Get an image's format type by processing the first 1K of the image.
Definition: emutil.cpp:396
EMAN::EmIO
EmIO defines I/O operations on EM image format.
Definition: emio.h:45
EMAN::FitsIO
MRC file = header + data (nx x ny x nz).
Definition: fitsio.h:45
EMAN::Gatan2IO
Gatan2 Image file = header + data.
Definition: gatan2io.h:46
EMAN::IcosIO
ICOS file = header + data.
Definition: icosio.h:51
EMAN::ImagicIO2
IMAGIC-5 Header File Format.
Definition: imagicio2.h:70
EMAN::ImagicIO
IMAGIC-5 Header File Format.
Definition: imagicio.h:66
EMAN::LstFastIO
A LSX file is a high performance ASCII file that contains a list of image numbers and file names.
Definition: lstfastio.h:55
EMAN::LstIO
A LST file is an ASCII file that contains a list of image file names.
Definition: lstio.h:46
EMAN::MrcIO
MRC file = header + data (nx x ny x nz).
Definition: mrcio.h:45
EMAN::OmapIO
DSN6 MAP is composed of a series of records which are all 512 bytes long.
Definition: omapio.h:51
EMAN::PgmIO
A PGM file = header + data.
Definition: pgmio.h:47
EMAN::PifIO
PIF(Portable Image Format for EM Data) is an image format from Purdue University.
Definition: pifio.h:53
EMAN::SalIO
A SAL image is an image from Perkin Elmer PDS Microdensitometer.
Definition: salio.h:48
EMAN::SerIO
SER (Series File Format) is a file format created by Dr.
Definition: serio.h:56
EMAN::SingleSpiderIO
Single Spider Image I/O class.
Definition: sspiderio.h:45
EMAN::SitusIO
situs is a a Situs-specific format on a cubic lattice.
Definition: situsio.h:49
EMAN::SpiderIO
SPIDER: (System for Processing Image Data from Electron microscopy and Related fields) is an image pr...
Definition: spiderio.h:72
EMAN::V4L2IO
Read-only.
Definition: v4l2io.h:46
EMAN::VtkIO
VtkIO reads/writes VTK image file.
Definition: vtkio.h:73
EMAN::XplorIO
XPLOR image format is in ASCII:
Definition: xplorio.h:61
EMAN::decoder2x
static DecoderIx< 2 > decoder2x
Definition: eerio.h:177
EMAN::decoder1x
static DecoderIx< 1 > decoder1x
Definition: eerio.h:176
EMAN::decoder0x
static DecoderIx< 0 > decoder0x
Definition: eerio.h:175

References Assert, EMAN::decoder0x, EMAN::decoder1x, EMAN::decoder2x, ENTERFUNC, EXITFUNC, get_image_type(), IMAGE_AMIRA, IMAGE_DF3, IMAGE_DM3, IMAGE_DM4, IMAGE_EER, IMAGE_EER2X, IMAGE_EER4X, 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_SER, IMAGE_SINGLE_SPIDER, IMAGE_SITUS, IMAGE_SPIDER, IMAGE_TIFF, IMAGE_UNKNOWN, IMAGE_V4L, IMAGE_VTK, IMAGE_XPLOR, ImageFormatException, EMAN::ImageIO::READ_ONLY, EMAN::ImageIO::READ_WRITE, and EMAN::ImageIO::WRITE_ONLY.

Referenced by EMAN::LstFastIO::calc_ref_image_index(), EMAN::LstIO::calc_ref_image_index(), get_image_count(), and read_binedimage().

◆ get_imagetype_name()

const char * EMUtil::get_imagetype_name ( EMUtil::ImageType  type)
static

Give each image type a meaningful name.

Parameters
typeImage format type.
Returns
A name for that type.

Definition at line 734 of file emutil.cpp.

735{
736 switch (t) {
737 case IMAGE_V4L:
738 return "V4L2";
739 break;
740 case IMAGE_MRC:
741 return "MRC";
742 break;
743 case IMAGE_SPIDER:
744 return "SPIDER";
745 break;
746 case IMAGE_SINGLE_SPIDER:
747 return "Single-SPIDER";
748 break;
749 case IMAGE_IMAGIC:
750 return "IMAGIC";
751 break;
752 case IMAGE_PGM:
753 return "PGM";
754 break;
755 case IMAGE_LST:
756 return "LST";
757 break;
758 case IMAGE_LSTFAST:
759 return "Fast LST";
760 break;
761 case IMAGE_PIF:
762 return "PIF";
763 break;
764 case IMAGE_PNG:
765 return "PNG";
766 break;
767 case IMAGE_HDF:
768 return "HDF5";
769 break;
770 case IMAGE_DM3:
771 return "GatanDM3";
772 break;
773 case IMAGE_DM4:
774 return "GatanDM4";
775 break;
776 case IMAGE_TIFF:
777 return "TIFF";
778 break;
779 case IMAGE_VTK:
780 return "VTK";
781 break;
782 case IMAGE_SAL:
783 return "HDR";
784 break;
785 case IMAGE_ICOS:
786 return "ICOS_MAP";
787 break;
788 case IMAGE_EMIM:
789 return "EMIM";
790 break;
791 case IMAGE_GATAN2:
792 return "GatanDM2";
793 break;
794 case IMAGE_JPEG:
795 return "JPEG";
796 break;
797 case IMAGE_AMIRA:
798 return "AmiraMesh";
799 break;
800 case IMAGE_XPLOR:
801 return "XPLOR";
802 break;
803 case IMAGE_EM:
804 return "EM";
805 break;
806 case IMAGE_FITS:
807 return "FITS";
808 break;
809 case IMAGE_DF3:
810 return "DF3";
811 break;
812 case IMAGE_OMAP:
813 return "OMAP";
814 break;
815 case IMAGE_SITUS:
816 return "SITUS";
817 break;
818 case IMAGE_SER:
819 return "SER";
820 break;
821 case IMAGE_UNKNOWN:
822 return "unknown";
823 }
824
825 return "unknown";
826}

References IMAGE_AMIRA, IMAGE_DF3, IMAGE_DM3, IMAGE_DM4, 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_SER, IMAGE_SINGLE_SPIDER, IMAGE_SITUS, IMAGE_SPIDER, IMAGE_TIFF, IMAGE_UNKNOWN, IMAGE_V4L, IMAGE_VTK, and IMAGE_XPLOR.

◆ get_region_dims()

void EMUtil::get_region_dims ( const Region *  area,
int  nx,
int *  area_x,
int  ny,
int *  area_y,
int  nz = 1,
int *  area_z = 0 
)
static

Get a region's dimensions.

Parameters
areaThe region area.
nxImage x size.
area_xThe pointer used to return the region x size.
nyImage y size.
area_yThe pointer used to return the region y size.
nzImage z size.
area_zThe pointer used to return the region z size.

Definition at line 860 of file emutil.cpp.

862{
863 Assert(area_x);
864 Assert(area_y);
865
866 if (! area) {
867 *area_x = nx;
868 *area_y = ny;
869
870 if (area_z) {
871 *area_z = nz;
872 }
873 }
874 else {
875 Vec3i size = area->get_size();
876 *area_x = size[0];
877 *area_y = size[1];
878
879 if (area_z) {
880 if (area->get_ndim() > 2 && nz > 1) {
881 *area_z = size[2];
882 }
883 else {
884 *area_z = 1;
885 }
886 }
887
888 }
889}
EMAN::Region::get_size
vector< float > get_size() const
get the size of each dimension as a vector
Definition: geometry.h:627
EMAN::Region::get_ndim
int get_ndim() const
Get the region's dimension.
Definition: geometry.h:644

References Assert, EMAN::Region::get_ndim(), and EMAN::Region::get_size().

Referenced by process_ascii_region_io(), process_region_io(), EMAN::MrcIO::read_fei_header(), and EMAN::MrcIO::read_mrc_header().

◆ get_region_origins()

void EMUtil::get_region_origins ( const Region *  area,
int *  p_x0,
int *  p_y0,
int *  p_z0 = 0,
int  nz = 1,
int  image_index = 0 
)
static

Get a region's original locations.

Parameters
areaThe region area.
p_x0The pointer used to return the region x origin.
p_y0The pointer used to return the region y origin.
p_z0The pointer used to return the region z origin.
nzImage z size.
image_indexImage index.

Definition at line 891 of file emutil.cpp.

893{
894 Assert(p_x0);
895 Assert(p_y0);
896
897 if (area) {
898 *p_x0 = static_cast < int >(area->origin[0]);
899 *p_y0 = static_cast < int >(area->origin[1]);
900
901 if (p_z0 && nz > 1 && area->get_ndim() > 2) {
902 *p_z0 = static_cast < int >(area->origin[2]);
903 }
904 }
905 else {
906 *p_x0 = 0;
907 *p_y0 = 0;
908
909 if (p_z0) {
910 *p_z0 = nz > 1 ? 0 : image_index;
911 }
912 }
913}
EMAN::Region::origin
FloatPoint origin
Definition: geometry.h:654

References Assert, EMAN::Region::get_ndim(), and EMAN::Region::origin.

◆ getRenderLimits()

void EMUtil::getRenderLimits ( const Dict &  dict,
float &  rendermin,
float &  rendermax,
int &  renderbits 
)
static

Get the min and max pixel value accepted for image nomalization from image attribute dictionary, or return zeroes if not present.

Parameters
[in]dictimage attribute dictionary
[out]renderminthe minimum value for normalization
[out]rendermaxthe maximum value for normalization
[out]renderbitsthe number of significant bits to retain when performing int conversion (helps with compression)

Definition at line 1689 of file emutil.cpp.

1690{
1691 // This routine used to have some complicated logic for specifying the limits in various ways
1692 // that is now gone (as far as I can tell, nobody had ever used it), and replaced by the later
1693 // logic in getRenderMinMax, which is triggered when render_max<=render_min
1694 // at present this routine just reads header values. It is still here in case we need to implement
1695 // more complicated logic in future.
1696 rendermin = 0.0; // when rendermax<=rendermin, automatic mode is invoked
1697 rendermax = 0.0;
1698
1699 if (dict.has_key("render_bits")) renderbits = (int)dict["render_bits"];
1700 else renderbits=0; // 0 bits means float mode, any compression will be truly lossless
1701
1702 if (dict.has_key("render_min")) rendermin = (float) dict["render_min"];
1703 if (dict.has_key("render_max")) rendermax = (float) dict["render_max"];
1704}
EMAN::Dict::has_key
bool has_key(const string &key) const
Ask the Dictionary if it as a particular key.
Definition: emobject.h:511

References EMAN::Dict::has_key().

◆ getRenderMinMax()

void EMUtil::getRenderMinMax ( float *  data,
const int  nx,
const int  ny,
float &  rendermin,
float &  rendermax,
int &  renderbits,
const int  nz = 1 
)
static

Calculate the min and max pixel value accepted for 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.

Parameters
[in]data2D image's data array
[in]nxx dimension size
[in]nyy dimension size
[out]renderminthe minimum value for normalization
[out]rendermaxthe maximum value for normalization
[out]renderbitsthe number of significant bits to retain when performing int conversion (helps with compression)
[in]nzz dimension size

Definition at line 1706 of file emutil.cpp.

1708{
1709 const float flag_base = 1.0e30;
1710 const float use_data_min_or_max = -flag_base;
1711 const float use_num_std_devs = flag_base / 100.0;
1712
1713 float num_std_devs;
1714
1715 bool debug = 0;
1716
1717 if (debug) printf ("into RenderMinMax, rmin = %g, rmax = %g, rbits = %d\n", rendermin, rendermax, renderbits);
1718
1719 if (renderbits<=0) return; // this is for float mode where rendermin/max isn't used
1720 if (renderbits>16) renderbits=16;
1721
1722 if (rendermax <= rendermin ||
1723 Util::is_nan(rendermin) || Util::is_nan(rendermax) ||
1724 fabs(rendermin) > use_num_std_devs ||
1725 fabs(rendermax) > use_num_std_devs) {
1726
1727 double m = 0.0f, s = 0.0f;
1728 size_t nint=0,n0=0,n1=0; // count the number of integers, zeroes and ones
1729 size_t size = (size_t)nx*ny*nz;
1730 float min = data[0], max = data[0];
1731 int bitval = 1<<renderbits;
1732
1733 // we compute image statistics. If this were designed right, we'd have the actual image instead of just
1734 // the data pointer and wouldn't need to do this (other than maybe the integer counting)
1735 for (size_t i = 0; i < size; ++i) {
1736 m += data[i];
1737 s += data[i] * data[i];
1738 if (data[i]==0.0f) n0++;
1739 else if (data[i]==1.0f) n1++;
1740 if (data[i]==floor(data[i])) nint++;
1741
1742 min = data[i] < min ? data[i] : min;
1743 max = data[i] > max ? data[i] : max;
1744// if (!Util::goodf(&data[i])) printf("NAN in image at pixel %ld\n",i);
1745 }
1746
1747
1748 float mnz = m/(size-n0); // mean, excluding zeroes
1749 float snz = sqrt(s/(size-n0)-mnz*mnz); // sigma, excluding zeroes
1750 m /= (float)(size);
1751 s = sqrt(s/(float)(size)-m*m);
1752
1753// // experimental code for looking at various limit testing schemes
1754// double s0=0,s1=1,sk0=0,sk1=0,ku0=0,ku1=0;
1755// size_t nn0=0,nn1=0;
1756// for (size_t i = 0; i < size; ++i) {
1757// if (data[i]<m) {
1758// s0+=pow(data[i]-m,2.0);
1759// sk0+=pow(m-data[i],3.0);
1760// ku0+=pow(data[i]-m,4.0);
1761// nn0++;
1762// }
1763// else if (data[i]>m) {
1764// s1+=pow(data[i]-m,2.0);
1765// sk1+=pow(data[i]-m,3.0);
1766// ku1+=pow(data[i]-m,4.0);
1767// nn1++;
1768// }
1769// }
1770// s0=pow(s0/nn0,0.5);
1771// s1=pow(s1/nn1,0.5);
1772// sk0=pow(sk0/nn0,1.0/3.0);
1773// sk1=pow(sk1/nn1,1.0/3.0);
1774// ku0=pow(ku0/nn0,0.25);
1775// ku1=pow(ku1/nn1,0.25);
1776// printf("\n%f %f %f %f %f %f",s0,s1,sk0,sk1,ku0,ku1);
1777// printf("\n%f - %f %f - %f %f - %f",m-s0*4.0,m+s1*4.0,m-sk0*4.0,m+sk1*4.0,m-ku0*4.0,m+ku1*4.0);
1778// printf ("\nmin, mean, max, s.d., nint, nzer, none = %g %g %g %g %d %d %d\n", min, m, max, s, nint, n0, n1);
1779// // end of experimental code
1780
1781
1782 if (debug) printf ("min, mean, max, s.d., nint, nzer, none = %g %g %g %g %d %d %d\n", min, m, max, s, nint, n0, n1);
1783
1784 if (s <= 0 || Util::is_nan(s)) s = 1.0; // this means all data values are the same
1785
1786 // probably a mask, or another imaged normalized to a range of 1 , binary or smoothed, treat it the same
1787 if ((max-min)==1) {
1788 rendermin=min;
1789 rendermax=max;
1790 }
1791 // all integer values, make sure we get integers back when we read, even if reduced bits
1792 else if (nint==size) {
1793 // if true, then we can safely store all of the values in the requested bits without change
1794 if (max-min<bitval) {
1795 rendermin=min;
1796 rendermax=min+bitval-1;
1797 }
1798 // otherwise, we will need to keep the most significant bits, but still try to get integers out (except in very odd cases)
1799 else {
1800 int neededbits=ceil(log(max-min+1)/log(2.0f));
1801 int step = 1<<(neededbits-renderbits);
1802 if (min<0<max) {
1803 rendermin = round( min / step ) * step;
1804 }
1805 else {
1806 rendermin=min;
1807 }
1808 rendermax=rendermin+step*(bitval-1);
1809 }
1810 }
1811 // Now into the more general case, but we still wish to preserve zero if present in significant numbers
1812 // TODO: This raises the tricky point of what would happen if you had a masked volume then added 0.0001 to it?
1813 // statistics might produce poor results. May need to consider using kurtosis instead of zero detection
1814 else if (min<0<max) { // 10 is arbitrary, just looking for a profusion of exactly zero values implying a mask
1815 // The first two seem stupid since they result in rendermin=min, rendermax=max, but we retain the option
1816 // of a more involved calculation to avoid outliers compressing the histogram to an unreasonable level
1817 if (min==0) {
1818 rendermin=0;
1819 rendermax=max; // keep everything, will only have issues with very large outliers
1820// rendermax=(mnz+snz*6.0)>max?max:mnz+snz*6.0; //TODO <- how large a sigma multiplier?
1821 }
1822 else if (max==0) {
1823 rendermax=0;
1824 rendermin=min;
1825// rendermin=(mnz-snz*6.0)<min?min:mnz-snz*6.0;
1826 }
1827 else {
1828 float step = (max-min)/(bitval-1);
1829 if (min == floor( min/step ) * step) {
1830 rendermin=min;
1831 rendermax=max;
1832 }
1833 else {
1834 // rendermin=(mnz-snz*4.0)<min?min:mnz-snz*4.0; // 4 standard deviations from the mean seems good empirically, e2iminfo.py -asO
1835 // rendermax=(mnz+snz*4.0)>max?max:mnz+snz*4.0;
1836 // logically impossible
1837 // if (min>0) min=0;
1838 // if (max<0) max=0;
1839 // if (rendermin==min && rendermax!=max) rendermax=(min+snz*8.0)>max?max:min+snz*8.0;
1840 // if (rendermin!=min && rendermax==max) rendermin=(max-snz*8.0)<min?min:max-snz*8.0;
1841 // float step=(rendermax-rendermin)/(bitval-1);
1842 // rendermin=ceil(rendermin/step)*step; // adjust rendermin so integral number of steps to exactly zero, may be roundoff issues
1843 step=(max-min)/(bitval-2); // -2 instead of -1 to give enough range to accommodate exactly 0
1844 rendermin=(floor(min/step)*step); // rendermin will be an integral number of steps from zero
1845 rendermax=rendermin+step*(bitval-1);
1846 }
1847 }
1848 }
1849 // Most general case, no "special values" to preserve
1850 else {
1851// rendermin=(m-s*4.0)<min?min:m-s*4.0; // 4 standard deviations from the mean seems good empirically, e2iminfo.py -asO
1852// rendermax=(m+s*4.0)>max?max:m+s*4.0;
1853// if (rendermin==min && rendermax!=max) rendermax=(min+s*8.0)>max?max:min+s*8.0;
1854// if (rendermin!=min && rendermax==max) rendermin=(max-s*8.0)<min?min:max-s*8.0;
1855 // Intelligent outlier removal is just too risky. large outliers are still a risk, but we'll stay conservative for now
1856 rendermin=min;
1857 rendermax=max;
1858 }
1859 }
1860
1861 if (debug) printf ("out of RenderMinMax, rmin = %g, rmax = %g, rbits = %d\n", rendermin, rendermax, renderbits);
1862}
EMAN::Util::is_nan
static bool is_nan(const float number)
tell whether a float value is a NaN
Definition: util.h:105
log
EMData * log() const
return natural logarithm image for a image
Definition: emdata_core.cpp:1114
sqrt
EMData * sqrt() const
return square root of current image
Definition: emdata_core.cpp:1084

References EMAN::Util::is_nan(), log(), and sqrt().

◆ is_complex_type()

bool EMUtil::is_complex_type ( EMDataType  datatype)
static

Definition at line 1231 of file emutil.cpp.

1232{
1233 return datatype == EM_SHORT_COMPLEX ||
1234 datatype == EM_USHORT_COMPLEX ||
1235 datatype == EM_FLOAT_COMPLEX;
1236}

References EM_FLOAT_COMPLEX, EM_SHORT_COMPLEX, and EM_USHORT_COMPLEX.

Referenced by EMAN::TestUtil::make_image_file_by_mode(), and EMAN::TestUtil::verify_image_file_by_mode().

◆ is_same_ctf()

bool EMUtil::is_same_ctf ( const EMData *  image1,
const EMData *  image2 
)
static

Check whether two EMData images have the same CTF parameters.

Parameters
image1The first EMData image.
image2The second EMData image.
Returns
whether two EMData images have the same CTF.

Definition at line 1275 of file emutil.cpp.

1276{
1277 if (!image1) {
1278 throw NullPointerException("image1 is NULL");
1279 }
1280
1281 if (!image2) {
1282 throw NullPointerException("image2 is NULL");
1283 }
1284
1285 Ctf *ctf1 = image1->get_ctf();
1286 Ctf *ctf2 = image2->get_ctf();
1287
1288 if ((!ctf1 && !ctf2) && (image1->has_ctff() == false && image2->has_ctff() == false)) {
1289 return true;
1290 }
1291
1292 if (ctf1 && ctf2) {
1293 bool result = ctf1->equal(ctf2);
1294 delete ctf1;
1295 ctf1 = NULL;
1296 delete ctf2;
1297 ctf2 = NULL;
1298
1299 return result;
1300 }
1301
1302 return false;
1303}
EMAN::Ctf
Ctf is the base class for all CTF model.
Definition: ctf.h:60
EMAN::Ctf::equal
virtual bool equal(const Ctf *ctf1) const =0
NullPointerException
#define NullPointerException(desc)
Definition: exception.h:241

References EMAN::Ctf::equal(), and NullPointerException.

◆ is_same_size()

bool EMUtil::is_same_size ( const EMData *  image1,
const EMData *  image2 
)
static

Check whether two EMData images are of the same size.

Parameters
image1The first EMData image.
image2The second EMData image.
Returns
Whether two EMData images are of the same size.

Definition at line 1224 of file emutil.cpp.

1225{
1226 return em1->get_xsize() == em2->get_xsize() &&
1227 em1->get_ysize() == em2->get_ysize() &&
1228 em1->get_zsize() == em2->get_zsize();
1229}

Referenced by EMAN::ImageAverager::add_image(), EMAN::FourierWeightAverager::add_image(), EMAN::TomoAverager::add_image(), EMAN::MinMaxAverager::add_image(), EMAN::MedianAverager::add_image(), EMAN::CtfWtAverager::add_image(), EMAN::CtfWtFiltAverager::add_image(), EMAN::CtfCAutoAverager::add_image(), EMAN::CtfCWautoAverager::add_image(), EMAN::SigmaAverager::add_image(), EMAN::EMData::add_incoherent(), EMAN::EMData::calc_ccfx(), EMAN::NormalizeCircleMeanProcessor::calc_mean(), EMAN::EMData::calc_mutual_correlation(), EMAN::EMData::common_lines(), EMAN::EMData::common_lines_real(), EMAN::EMData::convolute(), EMAN::EMData::dot_rotate_translate(), get_circle_mean(), EMAN::IndexMaskFileProcessor::process_inplace(), and EMAN::Cmp::validate_input_args().

◆ is_valid_filename()

bool EMUtil::is_valid_filename ( const string &  filename)
static

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.

Parameters
filenameImage file name.
Returns
whether or not it is a valid filename

Definition at line 222 of file emutil.cpp.

223{
224 ImageType type = get_image_ext_type(Util::get_filename_ext(filename));
225
226 return (type != IMAGE_UNKNOWN);
227}

References EMAN::Util::get_filename_ext(), get_image_ext_type(), and IMAGE_UNKNOWN.

◆ jump_lines()

void EMUtil::jump_lines ( FILE *  file,
int  nlines 
)
static

Definition at line 1493 of file emutil.cpp.

1494{
1495 Assert(file);
1496
1497 if (nlines > 0) {
1498 char line[MAXPATHLEN];
1499
1500 for (int l = 0; l < nlines; l++) {
1501 if (!fgets(line, sizeof(line), file)) {
1502 Assert("read xplor file failed");
1503 }
1504 }
1505 }
1506}

References Assert.

Referenced by jump_lines_by_items(), and process_ascii_region_io().

◆ jump_lines_by_items()

void EMUtil::jump_lines_by_items ( FILE *  file,
int  nitems,
int  nitems_per_line 
)
staticprivate

Definition at line 1473 of file emutil.cpp.

1474{
1475 Assert(file);
1476 Assert(nitems_per_line > 0);
1477
1478 if (nitems <= 0) {
1479 return;
1480 }
1481
1482 int nlines = nitems / nitems_per_line;
1483
1484 if ((nitems % nitems_per_line) != 0) {
1485 nlines++;
1486 }
1487
1488 if (nlines > 0) {
1489 jump_lines(file, nlines);
1490 }
1491}
EMAN::EMUtil::jump_lines
static void jump_lines(FILE *file, int nlines)
Definition: emutil.cpp:1493

References Assert, and jump_lines().

Referenced by process_ascii_region_io().

◆ mode_size_product()

double EMUtil::mode_size_product ( size_t  factor,
size_t  mode_size 
)
static

Return a factor times the mode size, which may be a special value (11111111) meaning one half, needed for MRC packed 8 bit format.

Definition at line 915 of file emutil.cpp.

916{
917 const size_t mode_size_half = 11111111;
918
919 double product;
920
921 if (mode_size == mode_size_half) {
922 product = factor * 0.5;
923 }
924 else {
925 product = factor * mode_size;
926 }
927
928 return product;
929}

Referenced by process_region_io().

◆ process_ascii_region_io()

void EMUtil::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 
)
static

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 1365 of file emutil.cpp.

1369{
1370 Assert(data != 0);
1371 Assert(file != 0);
1372 Assert(rw_mode == ImageIO::READ_ONLY ||
1373 rw_mode == ImageIO::READ_WRITE ||
1374 rw_mode == ImageIO::WRITE_ONLY);
1375
1376 int xlen = 0, ylen = 0, zlen = 0;
1377 get_region_dims(area, nx, &xlen, ny, &ylen, nz, &zlen);
1378
1379 int x0 = 0;
1380 int y0 = 0;
1381 int z0 = 0;
1382
1383 if (area) {
1384 x0 = (int)area->origin[0];
1385 y0 = (int)area->origin[1];
1386 z0 = (int)area->origin[2];
1387 }
1388
1389 int nlines_per_sec = (nx *ny) / nitems_per_line;
1390 int nitems_last_line = (nx * ny) % nitems_per_line;
1391
1392 if (nitems_last_line != 0) {
1393 nlines_per_sec++;
1394 }
1395
1396 if (has_index_line) {
1397 nlines_per_sec++;
1398 }
1399
1400 if (z0 > 0) {
1401 jump_lines(file, z0 * nlines_per_sec);
1402 }
1403
1404 int nlines_pre_sec = (y0 * nx + x0) / nitems_per_line;
1405 int gap_nitems = nx - xlen;
1406 int ti = 0;
1407 int rlines = 0;
1408
1409 for (int k = 0; k < zlen; k++) {
1410 EMUtil::jump_lines(file, nlines_pre_sec+1);
1411
1412 int head_nitems = (y0 * nx + x0) % nitems_per_line;
1413 int tail_nitems = 0;
1414 bool is_head_read = false;
1415
1416 for (int j = 0; j < ylen; j++) {
1417 if (head_nitems > 0 && !is_head_read) {
1418 EMUtil::process_numbers_io(file, rw_mode, nitems_per_line, mode_size,
1419 nitems_per_line-head_nitems,
1420 nitems_per_line-1, data, &ti, outformat);
1421 rlines++;
1422 }
1423
1424 EMUtil::process_lines_io(file, rw_mode, nitems_per_line,
1425 mode_size, (xlen - head_nitems),
1426 data, &ti, outformat);
1427
1428 rlines += ((xlen - head_nitems) / nitems_per_line);
1429
1430 tail_nitems = (xlen - head_nitems) % nitems_per_line;
1431
1432 if ((gap_nitems + tail_nitems) > 0) {
1433 head_nitems = nitems_per_line -
1434 (gap_nitems + tail_nitems) % nitems_per_line;
1435 }
1436 else {
1437 head_nitems = 0;
1438 }
1439
1440 is_head_read = false;
1441
1442 if (tail_nitems > 0) {
1443 if ((gap_nitems < (nitems_per_line-tail_nitems)) &&
1444 (j != (ylen-1))) {
1445 EMUtil::exclude_numbers_io(file, rw_mode, nitems_per_line,
1446 mode_size, tail_nitems,
1447 tail_nitems+gap_nitems-1, data, &ti, outformat);
1448 is_head_read = true;
1449 rlines++;
1450 }
1451 else {
1452 EMUtil::process_numbers_io(file, rw_mode, nitems_per_line, mode_size,
1453 0, tail_nitems-1, data, &ti, outformat);
1454 rlines++;
1455 }
1456 }
1457
1458 if (gap_nitems > (nitems_per_line-tail_nitems)) {
1459 int gap_nlines = (gap_nitems - (nitems_per_line-tail_nitems)) /
1460 nitems_per_line;
1461
1462 if (gap_nlines > 0 && j != (ylen-1)) {
1463 EMUtil::jump_lines(file, gap_nlines);
1464 }
1465 }
1466 }
1467
1468 int ytail_nitems = (ny-ylen-y0) * nx + (nx-xlen-x0) - (nitems_per_line-tail_nitems);
1469 EMUtil::jump_lines_by_items(file, ytail_nitems, nitems_per_line);
1470 }
1471}
EMAN::EMUtil::jump_lines_by_items
static void jump_lines_by_items(FILE *file, int nitems, int nitems_per_line)
Definition: emutil.cpp:1473
EMAN::EMUtil::process_numbers_io
static 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)
Definition: emutil.cpp:1508
EMAN::EMUtil::exclude_numbers_io
static 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)
Definition: emutil.cpp:1554
EMAN::EMUtil::get_region_dims
static 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.
Definition: emutil.cpp:860
EMAN::EMUtil::process_lines_io
static 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)
Definition: emutil.cpp:1612

References Assert, exclude_numbers_io(), get_region_dims(), jump_lines(), jump_lines_by_items(), EMAN::Region::origin, process_lines_io(), process_numbers_io(), EMAN::ImageIO::READ_ONLY, EMAN::ImageIO::READ_WRITE, and EMAN::ImageIO::WRITE_ONLY.

◆ process_lines_io()

void EMUtil::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 
)
staticprivate

Definition at line 1612 of file emutil.cpp.

1616{
1617 Assert(file);
1618 Assert(data);
1619 Assert(p_i);
1620
1621 if (nitems > 0) {
1622 int nlines = nitems / nitems_per_line;
1623
1624 for (int i = 0; i < nlines; i++) {
1625 EMUtil::process_numbers_io(file, rw_mode, nitems_per_line, mode_size, 0,
1626 nitems_per_line-1, data, p_i, outformat);
1627 }
1628 }
1629}

References Assert, and process_numbers_io().

Referenced by process_ascii_region_io().

◆ process_numbers_io()

void EMUtil::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 
)
staticprivate

Definition at line 1508 of file emutil.cpp.

1511{
1512 Assert(file);
1513 Assert(start >= 0);
1514 Assert(start <= end);
1515 Assert(end <= nitems_per_line);
1516 Assert(data);
1517 Assert(p_i);
1518 Assert(outformat);
1519
1520 char line[MAXPATHLEN];
1521
1522 if (rw_mode == ImageIO::READ_ONLY) {
1523 if (!fgets(line, sizeof(line), file)) {
1524 Assert("read xplor file failed");
1525 }
1526
1527 int nitems_in_line = (int) (strlen(line) / mode_size);
1528 Assert(end <= nitems_in_line);
1529 vector<float> d(nitems_in_line);
1530 char * pline = line;
1531
1532 for (int i = 0; i < nitems_in_line; i++) {
1533 sscanf(pline, "%f", &d[i]);
1534 pline += (int)mode_size;
1535 }
1536
1537 for (int i = start; i <= end; i++) {
1538 data[*p_i] = d[i];
1539 (*p_i)++;
1540 }
1541 }
1542 else {
1543 portable_fseek(file, mode_size * start, SEEK_CUR);
1544
1545 for (int i = start; i <= end; i++) {
1546 fprintf(file, outformat, data[*p_i]);
1547 (*p_i)++;
1548 }
1549
1550 portable_fseek(file, mode_size * (nitems_per_line - end-1)+1, SEEK_CUR);
1551 }
1552}

References Assert, portable_fseek(), and EMAN::ImageIO::READ_ONLY.

Referenced by process_ascii_region_io(), and process_lines_io().

◆ process_region_io()

void EMUtil::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 
)
static

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)

Parameters
cdataData array.
fileThe image file pointer.
rw_modeRead/write mode. It is either READ_ONLY or WRITE_ONLY.
image_indexImage index.
mode_sizePixel size.
nxImage x size.
nyImage y size.
nzImage z size.
areaThe region to read/write.
need_flipDo we need flip the image?
imgtypeThe Image type of the processed file.
pre_rowFile size needed to be skipped before each row.
post_rowFile size needed to be skipped after each row.
Exceptions
ImageReadExceptionIf the read has some error.
ImageWriteExceptionIf the write has some error.

Definition at line 931 of file emutil.cpp.

936{
937 Assert(vdata != 0);
938 Assert(file != 0);
939 Assert(rw_mode == ImageIO::READ_ONLY ||
940 rw_mode == ImageIO::READ_WRITE ||
941 rw_mode == ImageIO::WRITE_ONLY);
942
943 if (mode_size == 0) throw UnexpectedBehaviorException("The mode size was 0?");
944
945 const size_t mode_size_half = 11111111;
946
947 unsigned char * cdata = (unsigned char *)vdata;
948
949 int dx0 = 0; // data x0
950 int dy0 = 0; // data y0
951 int dz0 = 0; // data z0
952
953 int fx0 = 0; // file x0
954 int fy0 = 0; // file y0
955 int fz0 = nz > 1 ? 0 : image_index; // file z0
956
957 int xlen = 0;
958 int ylen = 0;
959 int zlen = 0;
960
961 get_region_dims(area, nx, &xlen, ny, &ylen, nz, &zlen);
962
963 bool debug = (getenv("DEBUG_IO") != NULL);
964
965 if (debug) {
966 printf ("-------------- process_region_io --------------\n");
967 printf ("rw, indx, modsiz, nx, ny, nz = %d %d %ld %d %d %d\n",
968 rw_mode, image_index, mode_size, nx, ny, nz);
969 printf ("flip, imtyp, prerow, postrow = %d %d %d %d\n",
970 (int) need_flip, (int) imgtype, pre_row, post_row);
971 printf ("xlen, ylen, zlen = %d %d %d\n", xlen, ylen, zlen);
972
973 if (area != NULL) {
974 printf ("x0, y0, z0, mx, my, mz, ndim = %g %g %g %g %g %g %d\n",
975 area->x_origin(),
976 area->y_origin(),
977 area->z_origin(),
978 area->get_width(),
979 area->get_height(),
980 area->get_depth(),
981 area->get_ndim());
982 }
983 }
984
985 if (area) { // Accommodate for all boundary overlaps of the region
986 Vec3i origin = area->get_origin();
987
988 fx0 = origin[0]; dx0 = origin[0];
989 fy0 = origin[1]; dy0 = origin[1];
990
991 if (nz > 1 && area->get_ndim() > 2) {
992 fz0 = origin[2]; dz0 = origin[2];
993 }
994
995 if (need_flip) {
996 Vec3i size = area->get_size();
997 fy0 = ny-(origin[1]+size[1]);
998 }
999
1000 if (fx0 < 0) {
1001 dx0 *= -1;
1002 xlen = xlen + fx0; // because there are less reads
1003 fx0 = 0;
1004 } else {
1005 dx0 = 0;
1006 //fx0 *= -1;
1007 }
1008
1009 if (fy0 < 0) {
1010 dy0 *= -1;
1011 ylen = ylen + fy0; // because there are less reads
1012 fy0 = 0;
1013 } else {
1014 if (need_flip){
1015 dy0*=-1;
1016 }
1017 else dy0 = 0;
1018 //fy0 *= -1;
1019 }
1020
1021 if (fz0 < 0) {
1022 dz0 *= -1;
1023 zlen = zlen + fz0; // because there are less reads
1024 fz0 = 0;
1025 } else {
1026 dz0 = 0;
1027 //fz0 *= -1;
1028 }
1029
1030 if ((fx0 + xlen)> nx) xlen = nx-fx0;
1031 if ((fy0 + ylen)> ny) ylen = ny-fy0;
1032 if ((fz0 + zlen)> nz && nz > 1) zlen = nz-fz0;
1033
1034 // This is fine - the region was entirely outside the image
1035 if ( xlen <= 0 || ylen <= 0 || zlen <= 0 ) return;
1036
1037 if (mode_size == mode_size_half) {
1038 // Have an area with 8 bit packed MRC format
1039 // (2 4-bit valus per 8 bit byte),
1040 // with an effective mode size of half a byte,
1041 // where most x-pixel parameters need to be even
1042 // for everything to work well.
1043 bool error = false;
1044
1045 if (fx0 % 2 != 0 && false) { // Don't check right now.
1046 cout << "First region x-pixel location "
1047 "must be even for packed 8 bit MRC." << endl;
1048 error = true;
1049 }
1050
1051 if ((nx - fx0 - xlen) % 2 != 0 && false) { // Don't check right now.
1052 cout << "No. of x-pixel locations after region "
1053 "must be even for packed 8 bit MRC." << endl;
1054 error = true;
1055 }
1056
1057 if (xlen % 2 != 0) {
1058 cout << "No. of region x-pixels "
1059 "must be even for packed 8 bit MRC." << endl;
1060 error = true;
1061 }
1062
1063 if (error) {
1064 return;
1065 }
1066 }
1067 }
1068
1069 if (xlen <= 0) {
1070 cout << "Xlen was too small " << xlen << endl;
1071
1072 return;
1073 }
1074
1075 Vec3i size;
1076
1077 if (area != 0) size = area->get_size();
1078 else size = Vec3d(nx,ny,nz);
1079
1080 //size_t area_sec_size = ylen * mode_size_product(xlen, mode_size);
1081 size_t memory_sec_size = size[1] * mode_size_product(size[0], mode_size);
1082 size_t img_row_size = mode_size_product(nx, mode_size) +
1083 pre_row + post_row;
1084 size_t area_row_size = mode_size_product(xlen, mode_size);
1085 size_t memory_row_size = mode_size_product(size[0], mode_size);
1086
1087 if ( area_row_size <= 0 ) {
1088 cout << "Xlen was too small " << xlen << " mode_size " << mode_size << endl;
1089
1090 return;
1091 }
1092
1093 size_t x_pre_gap = mode_size_product(fx0, mode_size);
1094 size_t x_post_gap = mode_size_product(nx - fx0 - xlen, mode_size);
1095
1096 size_t y_pre_gap = fy0 * img_row_size;
1097 size_t y_post_gap = (ny - fy0 - ylen) * img_row_size;
1098
1099 if (x_pre_gap < 0) x_pre_gap = 0;
1100 if (x_post_gap < 0) x_post_gap = 0;
1101
1102 size_t extra = img_row_size - (x_pre_gap + area_row_size + x_post_gap);
1103
1104 if (extra > 0) x_post_gap += extra;
1105
1106 portable_fseek(file, img_row_size * ny * fz0, SEEK_CUR);
1107
1108 float nxlendata[1];
1109 int floatsize = (int) sizeof(float);
1110 nxlendata[0] = (float)(nx * floatsize);
1111
1112 if (debug) {
1113 printf ("fz0, dz0, xlen, ylen, zlen = %d %d %d %d %d\n",
1114 fz0, dz0, xlen, ylen, zlen);
1115 printf ("x_pre_gap, x_post_gap, y_pre_gap, y_post_gap = %d %d %d %d\n",
1116 x_pre_gap, x_post_gap, y_pre_gap, y_post_gap);
1117 printf ("mem_sec_siz, img_row_siz, are_row_siz, mem_row_siz = %ld %ld %ld %ld\n",
1118 memory_sec_size, img_row_size, area_row_size, memory_row_size);
1119 printf ("-----------------------------------------------\n");
1120 }
1121
1122 for (int k = dz0; k < (dz0+zlen); k++) {
1123 // k is image/slice number, starting from 0
1124 if (y_pre_gap > 0) {
1125 portable_fseek(file, y_pre_gap, SEEK_CUR);
1126 }
1127
1128 //long k2 = k * area_sec_size;
1129 long k2 = k*memory_sec_size;
1130
1131 for (int j = dy0; j < (dy0+ylen); j++) {
1132 if (pre_row > 0) {
1133 if (imgtype == IMAGE_ICOS && rw_mode != ImageIO::READ_ONLY && !area) {
1134 fwrite(nxlendata, floatsize, 1, file);
1135 }
1136 else {
1137 portable_fseek(file, pre_row, SEEK_CUR);
1138 }
1139 }
1140
1141 if (x_pre_gap > 0) {
1142 portable_fseek(file, x_pre_gap, SEEK_CUR);
1143 }
1144
1145 int jj = j;
1146
1147 if (need_flip) {
1148 jj = (dy0+ylen) - 1 - j;
1149
1150 // region considerations add complications
1151 // in the flipping scenario (imagic format)
1152 if (dy0 > 0) {
1153 jj += dy0;
1154 }
1155 }
1156
1157 if (rw_mode == ImageIO::READ_ONLY) {
1158 if (fread(&cdata[k2 + jj * memory_row_size +
1159 (size_t) mode_size_product(dx0, mode_size)],
1160 area_row_size, 1, file) != 1) {
1161
1162// cout << jj << " " << k2 << " " << memory_row_size
1163// << " " << dx0 << " "
1164// << mode_size << " " << area_row_size << " "
1165// << cdata << ftell(file) << "done" << endl;
1166
1167 cout << "Reached premature end-of-file reading "
1168 << "region from image/slice number " << k
1169 << " of file with " << ftell(file)
1170 << " bytes." << endl;
1171
1172 throw ImageReadException("Unknownfilename",
1173 "incomplete data read");
1174 }
1175 }
1176 else {
1177 if (fwrite(&cdata[k2 + jj * memory_row_size +
1178 (size_t) mode_size_product(dx0, mode_size)],
1179 area_row_size, 1, file) != 1) {
1180 throw ImageWriteException("", "incomplete data write");
1181 }
1182 }
1183
1184 if (x_post_gap > 0) {
1185 portable_fseek(file, x_post_gap, SEEK_CUR);
1186 }
1187
1188 if (post_row > 0) {
1189 if (imgtype == IMAGE_ICOS && rw_mode != ImageIO::READ_ONLY && !area) {
1190 fwrite(nxlendata, floatsize, 1, file);
1191 }
1192 else {
1193 portable_fseek(file, post_row, SEEK_CUR);
1194 }
1195 }
1196 }
1197
1198 if (y_post_gap > 0) {
1199 portable_fseek(file, y_post_gap, SEEK_CUR);
1200 }
1201 }
1202}
EMAN::EMUtil::mode_size_product
static double mode_size_product(size_t factor, size_t mode_size)
Return a factor times the mode size, which may be a special value (11111111) meaning one half,...
Definition: emutil.cpp:915
EMAN::Region::get_width
float get_width() const
get the width
Definition: geometry.h:606
EMAN::Region::y_origin
float y_origin() const
get the y element of the origin
Definition: geometry.h:622
EMAN::Region::x_origin
float x_origin() const
get the x element of the origin
Definition: geometry.h:620
EMAN::Region::get_origin
vector< float > get_origin() const
get the origin as a vector
Definition: geometry.h:629
EMAN::Region::get_depth
float get_depth() const
get the depth
Definition: geometry.h:610
EMAN::Region::z_origin
float z_origin() const
get the z element of the origin
Definition: geometry.h:624
EMAN::Region::get_height
float get_height() const
get the height
Definition: geometry.h:608
ImageReadException
#define ImageReadException(filename, desc)
Definition: exception.h:204
UnexpectedBehaviorException
#define UnexpectedBehaviorException(desc)
Definition: exception.h:400
ImageWriteException
#define ImageWriteException(imagename, desc)
Definition: exception.h:223
EMAN::Vec3d
Vec3< double > Vec3d
Definition: vec3.h:695

References Assert, EMAN::Region::get_depth(), EMAN::Region::get_height(), EMAN::Region::get_ndim(), EMAN::Region::get_origin(), get_region_dims(), EMAN::Region::get_size(), EMAN::Region::get_width(), IMAGE_ICOS, ImageReadException, ImageWriteException, mode_size_product(), portable_fseek(), EMAN::ImageIO::READ_ONLY, EMAN::ImageIO::READ_WRITE, UnexpectedBehaviorException, EMAN::ImageIO::WRITE_ONLY, EMAN::Region::x_origin(), EMAN::Region::y_origin(), and EMAN::Region::z_origin().

Referenced by EMAN::SpiderIO::write_single_data().

◆ vertical_acf()

EMData * EMUtil::vertical_acf ( const EMData *  image,
int  maxdy 
)
static

Definition at line 1238 of file emutil.cpp.

1239{
1240 if (!image) {
1241 throw NullPointerException("NULL Image");
1242 }
1243
1244 EMData *ret = new EMData();
1245
1246 int nx = image->get_xsize();
1247 int ny = image->get_ysize();
1248
1249 if (maxdy <= 1) {
1250 maxdy = ny / 8;
1251 }
1252
1253 ret->set_size(nx, maxdy, 1);
1254
1255 float *data = image->get_data();
1256 float *ret_data = ret->get_data();
1257
1258 for (int x = 0; x < nx; x++) {
1259 for (int y = 0; y < maxdy; y++) {
1260 float dot = 0;
1261
1262 for (int yy = maxdy; yy < ny - maxdy; yy++) {
1263 dot += data[x + (yy + y) * nx] * data[x + (yy - y) * nx];
1264 }
1265
1266 ret_data[x + y * nx] = dot;
1267 }
1268 }
1269
1270 ret->update();
1271
1272 return ret;
1273}
EMAN::EMData
EMData stores an image's data and defines core image processing routines.
Definition: emdata.h:82
EMAN::dot
double dot(const Vector3 &w, const Vector3 &v)
Definition: vecmath.h:305
y
#define y(i, j)
Definition: projector.cpp:1516
x
#define x(i)
Definition: projector.cpp:1517

References EMAN::dot(), NullPointerException, x, and y.

The documentation for this class was generated from the following files:
Generated by doxygen 1.9.2