EMAN::ImagicIO2 Class Reference

IMAGIC-5 Header File Format. More...

#include <imagicio2.h>

Inheritance diagram for EMAN::ImagicIO2:

Collaboration diagram for EMAN::ImagicIO2:

Classes
struct	Imagic4D
	IMAGIC-4D file format http://www.imagescience.de/formats/formats.htm. More...

Public Member Functions
	ImagicIO2 (const string &fname, IOMode rw_mode=READ_ONLY)
	~ImagicIO2 ()
int	init_test ()
bool	is_single_image_format () const
	If this file format is only for single iamge. More...
int	get_nimg ()
	Get number of images in this file. More...
Public Member Functions inherited from EMAN::ImageIO
	ImageIO (const string &fname, IOMode rw)
virtual	~ImageIO ()
virtual int	read_header (Dict &dict, int image_index=0, const Region *area=0, bool is_3d=false)=0
	Read the header from an image. More...
virtual int	write_header (const Dict &dict, int image_index=0, const Region *area=0, EMUtil::EMDataType filestoragetype=EMUtil::EM_FLOAT, bool use_host_endian=true)=0
	Write a header to an image. More...
virtual int	read_data (float *data, int image_index=0, const Region *area=0, bool is_3d=false)=0
	Read the data from an image. More...
virtual int	read_data_8bit (unsigned char *data, int image_index=0, const Region *area=0, bool is_3d=false, float minval=0.0f, float maxval=0.0f)
	Read the data from an image as an 8 bit array, regardless of format. More...
virtual int	write_data (float *data, int image_index=0, const Region *area=0, EMUtil::EMDataType filestoragetype=EMUtil::EM_FLOAT, bool use_host_endian=true)=0
	Write data to an image. More...
virtual int	read_ctf (Ctf &ctf, int image_index=0)
	Read CTF data from this image. More...
virtual void	write_ctf (const Ctf &ctf, int image_index=0)
	Write CTF data to this image. More...
virtual void	flush ()=0
	Flush the IO buffer. More...
virtual bool	is_complex_mode ()=0
	Is this an complex image or not. More...
virtual bool	is_image_big_endian ()=0
	Is this image in big endian or not. More...
template<class T >
void	become_host_endian (T *data, size_t n=1)
	Convert data of this image into host endian format. More...
string	get_filename () const

Static Public Member Functions
static bool	is_valid (const void *first_block)

Public Attributes
	DEFINE_IMAGEIO_FUNC

Static Public Attributes
static const char *	HED_EXT = "hed"
static const char *	IMG_EXT = "img"

Private Types
enum	DataType {   IMAGIC_CHAR , IMAGIC_SHORT , IMAGIC_FLOAT , IMAGIC_FLOAT_COMPLEX ,   IMAGIC_FFT_FLOAT_COMPLEX , IMAGIC_UNKNOWN_TYPE }
enum	{ NUM_4BYTES_PRE_IYLP = 14 , NUM_4BYTES_AFTER_IXOLD = 14 , NUM_4BYTES_AFTER_NAME = 150 }
enum	RealType { VAX_VMS = 16777216 , LINUX_WINDOWS = 33686018 , SGI_IBM = 67372036 }

Private Member Functions
size_t	get_datatype_size (DataType t) const
int	to_em_datatype (DataType t) const
void	make_header_host_endian (Imagic4D &hed) const
void	swap_header (Imagic4D &hed) const
DataType	get_datatype_from_name (const char *name) const
Ctf *	read_ctf (const Imagic4D &hed) const
	the Ctf object is a EMAN1Ctf object. More...
void	write_ctf (const Ctf *const ctf, int image_index=0)
int	generate_machine_stamp () const

Private Attributes
string	hed_filename
string	img_filename
FILE *	hed_file
FILE *	img_file
Imagic4D	imagich
bool	is_big_endian
bool	is_new_hed
bool	is_new_img
DataType	datatype
int	nz

Static Private Attributes
static const char *	REAL_TYPE_MAGIC = "REAL"
static const char *	CTF_MAGIC = "!-"

Additional Inherited Members
Public Types inherited from EMAN::ImageIO
enum	IOMode { READ_ONLY = 1 , READ_WRITE = 2 , WRITE_ONLY = 3 }
Protected Member Functions inherited from EMAN::ImageIO
virtual void	init ()=0
	Do some initialization before doing the read/write. More...
void	check_read_access (int image_index)
	Validate 'image_index' in file reading. More...
void	check_read_access (int image_index, const float *data)
	Validate 'image_index' and 'data' in file reading. More...
void	check_write_access (IOMode rw_mode, int image_index, int max_nimg=0)
	Validate rw_mode and image_index in file writing. More...
void	check_write_access (IOMode rw_mode, int image_index, int max_nimg, const float *data)
	Validate rw_mode, image_index, and data pointer in file writing. More...
void	check_region (const Region *area, const FloatSize &max_size, bool is_new_file=false, bool inbounds_only=true)
	Validate image I/O region. More...
void	check_region (const Region *area, const IntSize &max_size, bool is_new_file=false, bool inbounds_only=true)
	Validate image I/O region. More...
FILE *	sfopen (const string &filename, IOMode mode, bool *is_new=0, bool overwrite=false)
	Run fopen safely. More...
Protected Attributes inherited from EMAN::ImageIO
string	filename
IOMode	rw_mode
FILE *	file = nullptr
bool	initialized = false

Detailed Description

IMAGIC-5 Header File Format.

Renewed 4D version: http://www.imagescience.de/formats/formats.htm

An IMAGIC-5 file has 2 files: a) a header file with extension ".hed". It contains information for every image. b) an image file with extension ".img". It contains raw data.

The header file contains one (fixed-size) record per image stored. Every header record consists of 256 REAL/float for every image.

The image file contains only the raw data. Depending on the internal IMAGIC-5 format used, which can be REAL, INTG, PACK or COMP, the data is stored as REAL/float, INTEGER/int, INTEGER*1/byte or 2x REAL/float, respectively. The first pixel stored is the upper left one. The data is stored line by line, section by section, volume by volume.

3D imagic uses the same format to 2D. it is a bunch of 2D slices. use the 'hint' IS_3D to treat "2D slices" as 3D volume.

This renewed version support storing multiple 3D images in one file (header/data pair).

EMAN2 will read both old and new Imagic header, but write to new format from - Grant Tang.

Definition at line 69 of file imagicio2.h.

Member Enumeration Documentation

anonymous enum

anonymous enum

private

Enumerator
NUM_4BYTES_PRE_IYLP
NUM_4BYTES_AFTER_IXOLD
NUM_4BYTES_AFTER_NAME

Definition at line 115 of file imagicio2.h.

                {
                        NUM_4BYTES_PRE_IYLP = 14,
                        NUM_4BYTES_AFTER_IXOLD = 14,
                        NUM_4BYTES_AFTER_NAME = 150     //before HISTORY
                };

DataType

enum EMAN::ImagicIO2::DataType

private

Enumerator
IMAGIC_CHAR
IMAGIC_SHORT
IMAGIC_FLOAT
IMAGIC_FLOAT_COMPLEX
IMAGIC_FFT_FLOAT_COMPLEX
IMAGIC_UNKNOWN_TYPE

Definition at line 104 of file imagicio2.h.

                {
                        IMAGIC_CHAR,
                        IMAGIC_SHORT,
                        IMAGIC_FLOAT,
                        IMAGIC_FLOAT_COMPLEX,
                        IMAGIC_FFT_FLOAT_COMPLEX,
                        IMAGIC_UNKNOWN_TYPE
                };

RealType

enum EMAN::ImagicIO2::RealType

private

Enumerator
VAX_VMS
LINUX_WINDOWS
SGI_IBM

Definition at line 122 of file imagicio2.h.

                {
                        VAX_VMS = 16777216,                     //for VAX/VMS
                        LINUX_WINDOWS = 33686018,       //for OSF, ULTRIX, LINUX, MS WINDOWS
                        SGI_IBM = 67372036                      //for SiliconGraphics, SUN, HP, IBM
                };

Constructor & Destructor Documentation

ImagicIO2()

ImagicIO2::ImagicIO2 ( const string &  fname, IOMode  rw_mode = READ_ONLY  )

explicit

Definition at line 51 of file imagicio2.cpp.

:       ImageIO(fname, rw), hed_file(0), img_file(0)
{
        hed_filename = Util::change_filename_ext(filename, HED_EXT);
        img_filename = Util::change_filename_ext(filename, IMG_EXT);
 
        is_big_endian = ByteOrder::is_host_big_endian();
        is_new_hed = false;
        is_new_img = false;
        memset(&imagich, 0, sizeof(Imagic4D));
        imagich.count = -1;
        datatype = IMAGIC_UNKNOWN_TYPE;
        nz = 0;
}

References EMAN::Util::change_filename_ext(), EMAN::ImagicIO2::Imagic4D::count, datatype, EMAN::ImageIO::filename, HED_EXT, hed_filename, IMAGIC_UNKNOWN_TYPE, imagich, IMG_EXT, img_filename, is_big_endian, EMAN::ByteOrder::is_host_big_endian(), is_new_hed, is_new_img, and nz.

~ImagicIO2()

ImagicIO2::~ImagicIO2

(

)

Definition at line 66 of file imagicio2.cpp.

{
        if (hed_file) {
                fclose(hed_file);
                hed_file = 0;
        }
 
        if (img_file) {
                fclose(img_file);
                img_file = 0;
        }
}

References hed_file, and img_file.

Member Function Documentation

generate_machine_stamp()

int ImagicIO2::generate_machine_stamp ( ) const

private

Definition at line 636 of file imagicio2.cpp.

{
        int machinestamp;
 
#ifdef __sgi
        machinestamp = SGI_IBM;
#elif defined __OPENVMS__
        machinestamp = VAX_VMS;
#else
        machinestamp = LINUX_WINDOWS;
#endif
 
        return machinestamp;
}

References LINUX_WINDOWS, SGI_IBM, and VAX_VMS.

get_datatype_from_name()

ImagicIO2::DataType ImagicIO2::get_datatype_from_name ( const char *  name ) const

private

Definition at line 375 of file imagicio2.cpp.

{
        DataType t = IMAGIC_UNKNOWN_TYPE;
 
        if (strncmp(name, "PACK",4) == 0) {
                t = IMAGIC_CHAR;
        }
        else if (strncmp(name, "INTG",4) == 0) {
                t = IMAGIC_SHORT;
        }
        else if (strncmp(name, REAL_TYPE_MAGIC,4) == 0) {
                t = IMAGIC_FLOAT;
        }
        else if (strncmp(name, "COMP",4) == 0) {
                t = IMAGIC_FLOAT_COMPLEX;
        }
        else if (strncmp(name, "RECO",4) == 0) {
                t = IMAGIC_FFT_FLOAT_COMPLEX;
        }
        return t;
}

References IMAGIC_CHAR, IMAGIC_FFT_FLOAT_COMPLEX, IMAGIC_FLOAT, IMAGIC_FLOAT_COMPLEX, IMAGIC_SHORT, IMAGIC_UNKNOWN_TYPE, and REAL_TYPE_MAGIC.

get_datatype_size()

size_t ImagicIO2::get_datatype_size ( DataType  t ) const

private

Definition at line 751 of file imagicio2.cpp.

{
        size_t s = 0;
        switch (t) {
        case IMAGIC_CHAR:
                s = sizeof(unsigned char);
                break;
        case IMAGIC_SHORT:
                s = sizeof(unsigned short);
                break;
        case IMAGIC_FLOAT:
        case IMAGIC_FLOAT_COMPLEX:
        case IMAGIC_FFT_FLOAT_COMPLEX:
                s = sizeof(float);
                break;
        default:
                s = 0;
        }
 
        return s;
}

References IMAGIC_CHAR, IMAGIC_FFT_FLOAT_COMPLEX, IMAGIC_FLOAT, IMAGIC_FLOAT_COMPLEX, and IMAGIC_SHORT.

get_nimg()

int ImagicIO2::get_nimg ( )

virtual

Get number of images in this file.

Returns

number of images

Reimplemented from EMAN::ImageIO.

Definition at line 739 of file imagicio2.cpp.

{
        init();
        return imagich.count + 1;
}

References EMAN::ImagicIO2::Imagic4D::count, imagich, and EMAN::ImageIO::init().

init_test()

int ImagicIO2::init_test

(

)

Definition at line 123 of file imagicio2.cpp.

{
        ENTERFUNC;
 
        if (initialized) {
                return 1;
        }
 
        FILE *in = fopen(hed_filename.c_str(), "rb");
        if (!in) {
                throw FileAccessException(filename);
        }
 
        char first_block[1024];
        size_t n = fread(first_block, sizeof(char), sizeof(first_block), in);
 
        if (n == 0) {
                LOGERR("file '%s' is an empty file", filename.c_str());
                fclose(in);
                return -1;
        }
        fclose(in);
 
        const int *data = reinterpret_cast <const int *>(first_block);
        int nx = data[13];
        int ny = data[12];
        int izold = data[11];
 
        if(izold==nx*ny) {
                EXITFUNC;
                return -1;      //old style IMAGIC file
        }
        else {
                EXITFUNC;
                return 0;       //new IMAGIC4D file
        }
}

References ENTERFUNC, EXITFUNC, FileAccessException, EMAN::ImageIO::filename, hed_filename, EMAN::ImageIO::initialized, and LOGERR.

is_single_image_format()

bool EMAN::ImagicIO2::is_single_image_format ( ) const

inlinevirtual

If this file format is only for single iamge.

Returns

false this file format support stack

Reimplemented from EMAN::ImageIO.

Definition at line 89 of file imagicio2.h.

                {
                        return false;
                }

is_valid()

bool ImagicIO2::is_valid ( const void *  first_block )

static

Definition at line 161 of file imagicio2.cpp.

{
        ENTERFUNC;
 
        if (!first_block) {
                return false;
        }
 
        const int *data = static_cast < const int *>(first_block);
        int count = data[1];
        int headrec = data[3];
        int hour = data[7];
        int minute = data[8];
        int second = data[9];
        int rsize = data[10];
        int nx = data[13];
        int ny = data[12];
        int nz = data[60];
        int realtype = data[68];
 
        bool data_big_endian = ByteOrder::is_data_big_endian(&headrec);
 
        if (data_big_endian != ByteOrder::is_host_big_endian()) {
                ByteOrder::swap_bytes(&count);
                ByteOrder::swap_bytes(&headrec);
                ByteOrder::swap_bytes(&hour);
                ByteOrder::swap_bytes(&rsize);
                ByteOrder::swap_bytes(&nx);
                ByteOrder::swap_bytes(&ny);
                ByteOrder::swap_bytes(&nz);
                ByteOrder::swap_bytes(&realtype);
        }
 
        const int max_dim = 1 << 20;
        bool result = false;
 
        // this field realtype is unique to new Imagic-5 format
        if(realtype != VAX_VMS && realtype != LINUX_WINDOWS && realtype != SGI_IBM) {
                EXITFUNC;
                return result;
        }
        
        if (headrec == 1 &&
                count >= 0 && count < max_dim &&
                nx > 0 && nx < max_dim &&
                ny > 0 && ny < max_dim && 
                nz > 0 && nz < max_dim &&
                hour >= 0 && hour < 24 &&
                minute >=0 && minute <60 &&
                second >=0 && second <60) {
                result = true;
        }
 
        EXITFUNC;
        return result;
}

References ENTERFUNC, EXITFUNC, EMAN::ByteOrder::is_data_big_endian(), EMAN::ByteOrder::is_host_big_endian(), LINUX_WINDOWS, nz, SGI_IBM, EMAN::ByteOrder::swap_bytes(), and VAX_VMS.

make_header_host_endian()

void ImagicIO2::make_header_host_endian ( Imagic4D &  hed ) const

private

Definition at line 651 of file imagicio2.cpp.

{
        if (is_big_endian != ByteOrder::is_host_big_endian()) {
                swap_header(hed);
        }
}

References is_big_endian, EMAN::ByteOrder::is_host_big_endian(), and swap_header().

read_ctf()

Ctf * ImagicIO2::read_ctf ( const Imagic4D &  hed ) const

private

the Ctf object is a EMAN1Ctf object.

Definition at line 416 of file imagicio2.cpp.

{
        ENTERFUNC;
 
        Ctf * ctf_ = 0;
        size_t n = strlen(CTF_MAGIC);
 
        if (strncmp(imagich.label, CTF_MAGIC, n) == 0) {
                ctf_ = new EMAN1Ctf();
                string header_label(hed.label);
                // Note: this block was making things crash because it assumed the following if statement
                // was true - I added the if statement (d.woolford)
                if (header_label.size() > 2) {
                        string sctf = "O" + header_label.substr(2);
                        ctf_->from_string(sctf);
                }
        }
 
        EXITFUNC;
        return ctf_;
}

References CTF_MAGIC, ENTERFUNC, EXITFUNC, EMAN::Ctf::from_string(), imagich, and EMAN::ImagicIO2::Imagic4D::label.

swap_header()

void ImagicIO2::swap_header ( Imagic4D &  hed ) const

private

Definition at line 658 of file imagicio2.cpp.

{
        ByteOrder::swap_bytes((int *) &hed, NUM_4BYTES_PRE_IYLP);
        ByteOrder::swap_bytes(&hed.ixold, NUM_4BYTES_AFTER_IXOLD);
        ByteOrder::swap_bytes((int *) &hed.ccc3d, NUM_4BYTES_AFTER_NAME);
}

References EMAN::ImagicIO2::Imagic4D::ccc3d, EMAN::ImagicIO2::Imagic4D::ixold, NUM_4BYTES_AFTER_IXOLD, NUM_4BYTES_AFTER_NAME, NUM_4BYTES_PRE_IYLP, and EMAN::ByteOrder::swap_bytes().

Referenced by make_header_host_endian().

to_em_datatype()

int ImagicIO2::to_em_datatype ( DataType  t ) const

private

Definition at line 397 of file imagicio2.cpp.

{
        switch (t) {
        case IMAGIC_CHAR:
                return EMUtil::EM_CHAR;
        case IMAGIC_SHORT:
                return EMUtil::EM_SHORT;
        case IMAGIC_FLOAT:
                return EMUtil::EM_FLOAT;
        case IMAGIC_FLOAT_COMPLEX:
        case IMAGIC_FFT_FLOAT_COMPLEX:
                return EMUtil::EM_FLOAT_COMPLEX;
        default:
                break;
        }
 
        return EMUtil::EM_UNKNOWN;
}

References EMAN::EMUtil::EM_CHAR, EMAN::EMUtil::EM_FLOAT, EMAN::EMUtil::EM_FLOAT_COMPLEX, EMAN::EMUtil::EM_SHORT, EMAN::EMUtil::EM_UNKNOWN, IMAGIC_CHAR, IMAGIC_FFT_FLOAT_COMPLEX, IMAGIC_FLOAT, IMAGIC_FLOAT_COMPLEX, and IMAGIC_SHORT.

write_ctf()

void ImagicIO2::write_ctf ( const Ctf *const  ctf, int  image_index = 0  )

private

Definition at line 438 of file imagicio2.cpp.

{
        ENTERFUNC;
        init();
 
        size_t n = strlen(CTF_MAGIC);
        strcpy(imagich.label, CTF_MAGIC);
        string ctf_ = ctf->to_string().substr(1);
 
        //pad ctf_ to 80 char
        if(ctf_.size()>80) {
                ctf_ = ctf_.substr(0, 80);
        }
        else {
                string padded(80 - ctf_.size(), ' ');
                ctf_ = ctf_ + padded;
        }
 
        strncpy(&imagich.label[n], ctf_.c_str(), sizeof(imagich.label) - n);
 
        rewind(hed_file);
        if (fwrite(&imagich, sizeof(Imagic4D), 1, hed_file) != 1) {
                throw ImageWriteException(hed_filename, "Imagic Header");
        }
 
        EXITFUNC;
}

References CTF_MAGIC, ENTERFUNC, EXITFUNC, hed_file, hed_filename, ImageWriteException, imagich, EMAN::ImageIO::init(), EMAN::ImagicIO2::Imagic4D::label, and EMAN::Ctf::to_string().

Member Data Documentation

CTF_MAGIC

const char * ImagicIO2::CTF_MAGIC = "!-"

staticprivate

Definition at line 101 of file imagicio2.h.

Referenced by read_ctf(), and write_ctf().

datatype

DataType EMAN::ImagicIO2::datatype

private

Definition at line 259 of file imagicio2.h.

Referenced by ImagicIO2().

DEFINE_IMAGEIO_FUNC

EMAN::ImagicIO2::DEFINE_IMAGEIO_FUNC

Definition at line 78 of file imagicio2.h.

HED_EXT

const char * ImagicIO2::HED_EXT = "hed"

static

Definition at line 72 of file imagicio2.h.

Referenced by ImagicIO2().

hed_file

FILE* EMAN::ImagicIO2::hed_file

private

Definition at line 251 of file imagicio2.h.

Referenced by write_ctf(), and ~ImagicIO2().

hed_filename

string EMAN::ImagicIO2::hed_filename

private

Definition at line 248 of file imagicio2.h.

Referenced by ImagicIO2(), init_test(), and write_ctf().

imagich

Imagic4D EMAN::ImagicIO2::imagich

private

Definition at line 254 of file imagicio2.h.

Referenced by get_nimg(), ImagicIO2(), read_ctf(), and write_ctf().

IMG_EXT

const char * ImagicIO2::IMG_EXT = "img"

static

Definition at line 73 of file imagicio2.h.

Referenced by ImagicIO2().

img_file

FILE* EMAN::ImagicIO2::img_file

private

Definition at line 252 of file imagicio2.h.

Referenced by ~ImagicIO2().

img_filename

string EMAN::ImagicIO2::img_filename

private

Definition at line 249 of file imagicio2.h.

Referenced by ImagicIO2().

is_big_endian

bool EMAN::ImagicIO2::is_big_endian

private

Definition at line 255 of file imagicio2.h.

Referenced by ImagicIO2(), and make_header_host_endian().

is_new_hed

bool EMAN::ImagicIO2::is_new_hed

private

Definition at line 256 of file imagicio2.h.

Referenced by ImagicIO2().

is_new_img

bool EMAN::ImagicIO2::is_new_img

private

Definition at line 257 of file imagicio2.h.

Referenced by ImagicIO2().

nz

int EMAN::ImagicIO2::nz

private

Definition at line 260 of file imagicio2.h.

Referenced by ImagicIO2(), and is_valid().

REAL_TYPE_MAGIC

const char * ImagicIO2::REAL_TYPE_MAGIC = "REAL"

staticprivate

Definition at line 100 of file imagicio2.h.

Referenced by get_datatype_from_name().

---

The documentation for this class was generated from the following files:

• imagicio2.h
• imagicio2.cpp