MRC file = header + data (nx x ny x nz). More...

#include <mrcio.h>

Inheritance diagram for EMAN::MrcIO:

Collaboration diagram for EMAN::MrcIO:

[legend]

Classes
struct	FeiMrcExtHeader
	The extended header used by Fei MRC image. More...

struct	FeiMrcHeader
	Extended MRC format for tomography As used by Fei; original definition of extended header by Dave Agard and Bram Koster Contact Dustin Morado Dusti.nosp@m.n.Mo.nosp@m.rado@.nosp@m.uth..nosp@m.tmc.e.nosp@m.du for details. More...

struct	MrcHeader

Public Member Functions
	MrcIO (const string &fname, IOMode rw_mode=READ_ONLY)

	~MrcIO ()

int	read_ctf (Ctf &ctf, int image_index=0)
	Read CTF data from this image. More...

void	write_ctf (const Ctf &ctf, int image_index=0)
	Write CTF data to this image. More...

int	get_nimg ()
	Return the number of images in this image 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 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...

virtual bool	is_single_image_format () const
	Is this image format only storing 1 image 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, off_t file_size=0)

static int	get_mode_size (int mm)

static int	to_em_datatype (int mrcmode)

static int	to_mrcmode (int em_datatype, int is_complex)

Public Attributes
	DEFINE_IMAGEIO_FUNC

MrcHeader	mrch

FeiMrcHeader	feimrch

Private Types
enum	MrcMode { MRC_UCHAR = 0 , MRC_SHORT = 1 , MRC_FLOAT = 2 , MRC_SHORT_COMPLEX =3 , MRC_FLOAT_COMPLEX =4 , MRC_USHORT = 6 , MRC_UCHAR3 = 16 , MRC_CHAR = 17 , MRC_UHEX = 101 , MRC_UNKNOWN = 18 }

enum	{ MRC_NUM_LABELS = 10 , MRC_LABEL_SIZE = 80 , NUM_4BYTES_PRE_MAP = 52 , NUM_4BYTES_AFTER_MAP = 3 }

Private Member Functions
void	swap_header (MrcHeader &mrch)

void	update_stats (void *data, size_t size)
	This is a utility function used to calculate new min/max/mean/sigma when write MRC file as 16 bit or 8 bit. More...

int	read_mrc_header (Dict &dict, int image_index=0, const Region *area=0, bool is_3d=false)

int	read_fei_header (Dict &dict, int image_index=0, const Region *area=0, bool is_3d=false)

int	transpose (float *data, int nx, int ny, int nz) const

Static Private Member Functions
static int	generate_machine_stamp ()
	generate the machine stamp used in MRC image format. More...

static void	check_swap (const int data, const char filnam, bool show_errors, bool &do_swap, bool &have_err)
	This is a utility routine to tell whether to byte swap MRC header. More...

Private Attributes
int	mode_size

union {
MrcHeader mrch

FeiMrcHeader feimrch

};

bool	isFEI

bool	is_stack

int	stack_size

bool	is_8_bit_packed

bool	use_given_dimensions

int	is_ri

bool	is_big_endian

bool	is_new_file

bool	is_transpose

float	rendermin

float	rendermax

int	renderbits

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

static const char *	SHORT_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

MRC file = header + data (nx x ny x nz).

A MRC image file stores 1D, 2D or 3D image. The image's dimensions and pixel type are defined in the header.

Definition at line 44 of file mrcio.h.

Member Enumeration Documentation

◆ anonymous enum

anonymous enum

private

Enumerator
MRC_NUM_LABELS
MRC_LABEL_SIZE
NUM_4BYTES_PRE_MAP
NUM_4BYTES_AFTER_MAP

Definition at line 76 of file mrcio.h.

                     {
                        MRC_NUM_LABELS = 10,
                        MRC_LABEL_SIZE = 80,
                        NUM_4BYTES_PRE_MAP = 52,
                        NUM_4BYTES_AFTER_MAP = 3
                };

◆ MrcMode

enum EMAN::MrcIO::MrcMode

private

Enumerator
MRC_UCHAR
MRC_SHORT
MRC_FLOAT
MRC_SHORT_COMPLEX
MRC_FLOAT_COMPLEX
MRC_USHORT
MRC_UCHAR3
MRC_CHAR
MRC_UHEX
MRC_UNKNOWN

Definition at line 63 of file mrcio.h.

                             {
                        MRC_UCHAR = 0,
                        MRC_SHORT = 1,
                        MRC_FLOAT = 2,
                        MRC_SHORT_COMPLEX=3,
                        MRC_FLOAT_COMPLEX=4,
                        MRC_USHORT = 6,
                        MRC_UCHAR3 = 16,        // unsigned char * 3, for rgb data, non-standard
                        MRC_CHAR = 17,          // non-standard - signed char
                        MRC_UHEX = 101, // 2 4-bit values packed into each 8-bit byte
                        MRC_UNKNOWN = 18
                };

Constructor & Destructor Documentation

◆ MrcIO()

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

explicit

Definition at line 49 of file mrcio.cpp.

:       ImageIO(fname, rw), mode_size(0),
                isFEI(false), is_ri(0), is_new_file(false),
                is_transpose(false), is_stack(false), stack_size(1),
                is_8_bit_packed(false), use_given_dimensions(true),
                rendermin(0.0), rendermax(0.0), renderbits(16)
{
        memset(&mrch, 0, sizeof(MrcHeader));
        is_big_endian = ByteOrder::is_host_big_endian();
}

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

◆ ~MrcIO()

MrcIO::~MrcIO ( )

Definition at line 60 of file mrcio.cpp.

{
        if (file) {
                fclose(file);
                file = NULL;
        }
}

References EMAN::ImageIO::file.

Member Function Documentation

◆ check_swap()

void MrcIO::check_swap	(	const int *	data,
		const char *	filnam,
		bool	show_errors,
		bool &	do_swap,
		bool &	have_err
	)

staticprivate

This is a utility routine to tell whether to byte swap MRC header.

Definition at line 230 of file mrcio.cpp.

{
        int nx      = data[0];
        int ny      = data[1];
        int nz      = data[2];
        int mrcmode = data[3];
        int mapc    = data[16]; // Which axis corresponds to Columns  (X=1, Y=2, Z=3)
        int mapr    = data[17]; // Which axis corresponds to Rows     (X=1, Y=2, Z=3)
        int maps    = data[18]; // Which axis corresponds to Sections (X=1, Y=2, Z=3)
        int nsymbt  = data[23]; // the extra bytes for symmetry information
        int mach    = data[44]; // Machine endian stamp
 
        int nxw, nyw, nzw, modew, mapcw, maprw, mapsw, nsymw, machw;
 
        nxw   = nx;
        nyw   = ny;
        nzw   = nz;
        modew = mrcmode;
        mapcw = mapc;
        maprw = mapr;
        mapsw = maps;
        nsymw = nsymbt;
        machw = mach;
 
        ByteOrder::swap_bytes(&nxw);
        ByteOrder::swap_bytes(&nyw);
        ByteOrder::swap_bytes(&nzw);
        ByteOrder::swap_bytes(&modew);
        ByteOrder::swap_bytes(&mapcw);
        ByteOrder::swap_bytes(&maprw);
        ByteOrder::swap_bytes(&mapsw);
        ByteOrder::swap_bytes(&nsymw);
        ByteOrder::swap_bytes(&machw);
 
        const int max_dim = 1 << 20;
 
        int actual_stamp = MrcIO::generate_machine_stamp();
 
        bool debug = (getenv("DEBUG_MRC_SANITY"));
 
        string errmsg;
 
        have_err = false;
 
        if (mach == actual_stamp) {
                do_swap = false;
        }
        else if (machw == actual_stamp) {
                do_swap = true;
        }
        else {
                if (mrcmode == 0) {
                        if (1 <= mapr  &&  mapr <= 3  &&
                                 1 <= mapc  &&  mapc <= 3  &&
                                 1 <= maps  &&  maps <= 3) {
                                do_swap = false;
                        }
                        else if (1 <= maprw  &&  maprw <= 3  &&
                                      1 <= mapcw  &&  mapcw <= 3  &&
                                      1 <= mapsw  &&  mapsw <= 3) {
                                do_swap = true;
                        }
                        else {
                                double ave_xyz  = ((double) nx  + (double) ny  + (double) nz)  / 3.0;
                                double ave_xyzw = ((double) nxw + (double) nyw + (double) nzw) / 3.0;
 
                                if      (nx  > 0  &&  ny  > 0  &&  nz  > 0  &&  ave_xyz  <= max_dim) {
                                        do_swap = false;
                                }
                                else if (nxw > 0  &&  nyw > 0  &&  nzw > 0  &&  ave_xyzw <= max_dim) {
                                        do_swap = true;
                                }
                                else {
                                        have_err = true;
                                        do_swap  = false;
                                        errmsg = "MRC image dimensions nonpositive or too large.";
                                }
                        }
                }
                else {
                        if (mrcmode > 0  &&  mrcmode < 128) {
                                do_swap = false;
                        }
                        else if (modew > 0  &&  modew < 128) {
                                do_swap = true;
                        }
                        else {
                                have_err = true;
                                do_swap  = false;
                                errmsg = "MRC mode is not from 0 to 127.";
                        }
                }
        }
 
        if (debug  ||  (have_err  &&  show_errors)) {
                if (filnam) {
                        printf ("file name = '%s'.\n", filnam);
                }
 
                printf ("stamp: mach, file, swapd = %8.0x %8.0x %8.0x\n",
                                  actual_stamp, mach, machw);
                printf ("stamp: mach, file, swapd = %d %d %d\n",
                                  actual_stamp, mach, machw);
                printf ("nx, ny, nz, mode         = %d %d %d %d\n", nx,    ny,    nz,   mrcmode);
                printf ("nx, ny, nz, mode swapped = %d %d %d %d\n", nxw,   nyw,   nzw,  modew);
                printf ("mapc, mapr, maps         = %d %d %d\n",    mapc,  mapr,  maps);
                printf ("mapc, mapr, maps swapped = %d %d %d\n",    mapcw, maprw, mapsw);
                printf ("%s\n", errmsg.c_str());
        }
}

References generate_machine_stamp(), and EMAN::ByteOrder::swap_bytes().

Referenced by is_valid().

◆ generate_machine_stamp()

int MrcIO::generate_machine_stamp ( )

staticprivate

generate the machine stamp used in MRC image format.

Definition at line 1713 of file mrcio.cpp.

{
        int stamp = 0;
        char *p = (char *) (&stamp);
 
        if (ByteOrder::is_host_big_endian()) {
                p[0] = 0x11;
                p[1] = 0x11;
                p[2] = 0;
                p[3] = 0;
        }
        else {
                p[0] = 0x44;
                p[1] = 0x41;
                p[2] = 0;
                p[3] = 0;
        }
 
        return stamp;
}

References EMAN::ByteOrder::is_host_big_endian().

Referenced by check_swap().

◆ get_mode_size()

int MrcIO::get_mode_size ( int mm )

static

Definition at line 1595 of file mrcio.cpp.

{
        MrcIO::MrcMode m = static_cast < MrcMode > (mm);
 
        int msize = 0;
        switch (m) {
        case MRC_CHAR:
        case MRC_UCHAR:
                msize = sizeof(char);
                break;
        case MRC_SHORT:
        case MRC_USHORT:
        case MRC_SHORT_COMPLEX:
                msize = sizeof(short);
                break;
        case MRC_FLOAT:
        case MRC_FLOAT_COMPLEX:
                msize = sizeof(float);
                break;
        default:
                msize = 0;
        }
 
        return msize;
}

References MRC_CHAR, MRC_FLOAT, MRC_FLOAT_COMPLEX, MRC_SHORT, MRC_SHORT_COMPLEX, MRC_UCHAR, and MRC_USHORT.

Referenced by is_valid().

◆ get_nimg()

int MrcIO::get_nimg ( )

virtual

Return the number of images in this image file.

Reimplemented from EMAN::ImageIO.

Definition at line 1740 of file mrcio.cpp.

{
        init();
 
        return stack_size;
}

References EMAN::ImageIO::init(), and stack_size.

◆ is_valid()

bool MrcIO::is_valid	(	const void *	first_block,
		off_t	file_size = `0`
	)

static

Definition at line 342 of file mrcio.cpp.

{
        ENTERFUNC;
 
        if (! first_block) { // Null pointer - no data
                return false;
        }
 
        const int * data = (const int *) first_block;
 
        int nx      = data[0];
        int ny      = data[1];
        int nz      = data[2];
        int mrcmode = data[3];
        int nsymbt  = data[23]; // the extra bytes for symmetry information
 
        const int max_dim = 1 << 20;
 
        bool do_swap, have_err;
 
        check_swap(data, NULL, false, do_swap, have_err);
 
        if (have_err) {
                return false;
        }
 
        if (do_swap) {
                ByteOrder::swap_bytes(&nx);
                ByteOrder::swap_bytes(&ny);
                ByteOrder::swap_bytes(&nz);
                ByteOrder::swap_bytes(&mrcmode);
                ByteOrder::swap_bytes(&nsymbt);
        }
 
        if (mrcmode == MRC_SHORT_COMPLEX || mrcmode == MRC_FLOAT_COMPLEX) {
                nx *= 2;
        }
 
        if ((mrcmode >= MRC_UCHAR &&
                (mrcmode < MRC_UNKNOWN || mrcmode == MRC_UHEX)) &&
                (nx > 1 && nx < max_dim) && (ny > 0 && ny < max_dim)
                 && (nz > 0 && nz < max_dim)) {
 
//#ifndef SPIDERMRC // Spider MRC files don't satisfy the following test
 
                if (file_size > 0) {
                        off_t file_size1 = (off_t)nx * (off_t)ny * (off_t)nz *
                                (off_t)get_mode_size(mrcmode) +
                                (off_t)sizeof(MrcHeader) + nsymbt;
 
                        if (file_size == file_size1) {
                                return true;
                        }
 
//                      return false;
 
         // when size doesn't match, print error message instead of make it fail
 
                        LOGWARN("image size check fails, still try to read it...");
                }
                else {
                        return true;
                }
 
//#endif // SPIDERMRC
 
                return true;
        }
 
        EXITFUNC;
 
        return false;
}

References check_swap(), ENTERFUNC, EXITFUNC, get_mode_size(), LOGWARN, MRC_FLOAT_COMPLEX, MRC_SHORT_COMPLEX, MRC_UCHAR, MRC_UHEX, MRC_UNKNOWN, and EMAN::ByteOrder::swap_bytes().

Referenced by EMAN::EMUtil::fast_get_image_type(), and EMAN::EMUtil::get_image_type().

◆ read_ctf()

int MrcIO::read_ctf	(	Ctf &	ctf,
		int	image_index = `0`
	)

virtual

Read CTF data from this image.

Parameters

ctf	Used to store the CTF data.
image_index	The index of the image to read.

Returns: 0 if OK; 1 if error.

Reimplemented from EMAN::ImageIO.

Definition at line 1551 of file mrcio.cpp.

{
        ENTERFUNC;
 
        init();
 
        size_t n = strlen(CTF_MAGIC);
        int err = 1;
 
        if (strncmp(mrch.labels[0], CTF_MAGIC, n) == 0) {
                err = ctf.from_string(string(&mrch.labels[0][n]));
        }
 
        EXITFUNC;
 
        return err;
}

References CTF_MAGIC, ENTERFUNC, EXITFUNC, EMAN::Ctf::from_string(), EMAN::ImageIO::init(), EMAN::MrcIO::MrcHeader::labels, and mrch.

Referenced by read_mrc_header().

◆ read_fei_header()

int MrcIO::read_fei_header	(	Dict &	dict,
		int	image_index = `0`,
		const Region *	area = `0`,
		bool	is_3d = `false`
	)

private

Definition at line 574 of file mrcio.cpp.

{
        ENTERFUNC;
 
        if(image_index < 0) {
                image_index = 0;
        }
 
        init();
 
        check_region(area, FloatSize(feimrch.nx, feimrch.ny, feimrch.nz), is_new_file, false);
 
        int xlen = 0, ylen = 0, zlen = 0;
 
        EMUtil::get_region_dims(area, feimrch.nx, & xlen, feimrch.ny, & ylen, feimrch.nz, & zlen);
 
        dict["nx"] = xlen;
        dict["ny"] = ylen;
        dict["nz"] = zlen;
        dict["FEIMRC.nx"] = feimrch.nx;
        dict["FEIMRC.ny"] = feimrch.ny;
        dict["FEIMRC.nz"] = feimrch.nz;
 
        dict["datatype"] = to_em_datatype(feimrch.mode);        //=1, FEI-MRC file always use short for data type
 
        dict["FEIMRC.nxstart"] = feimrch.nxstart;
        dict["FEIMRC.nystart"] = feimrch.nystart;
        dict["FEIMRC.nzstart"] = feimrch.nzstart;
 
        dict["FEIMRC.mx"] = feimrch.mx;
        dict["FEIMRC.my"] = feimrch.my;
        dict["FEIMRC.mz"] = feimrch.mz;
 
        dict["FEIMRC.xlen"] = feimrch.xlen;
        dict["FEIMRC.ylen"] = feimrch.ylen;
        dict["FEIMRC.zlen"] = feimrch.zlen;
 
        dict["FEIMRC.alpha"] = feimrch.alpha;
        dict["FEIMRC.beta"] = feimrch.beta;
        dict["FEIMRC.gamma"] = feimrch.gamma;
 
        dict["FEIMRC.mapc"] = feimrch.mapc;
        dict["FEIMRC.mapr"] = feimrch.mapr;
        dict["FEIMRC.maps"] = feimrch.maps;
 
        dict["FEIMRC.minimum"] = feimrch.amin;
        dict["FEIMRC.maximum"] = feimrch.amax;
        dict["FEIMRC.mean"] = feimrch.amean;
//      dict["mean"] = feimrch.amean;
 
        dict["FEIMRC.ispg"] = feimrch.ispg;
        dict["FEIMRC.nsymbt"] = feimrch.nsymbt;
 
        dict["apix_x"] = feimrch.xlen / feimrch.mx;
        dict["apix_y"] = feimrch.ylen / feimrch.my;
        dict["apix_z"] = feimrch.zlen / feimrch.mz;
 
        dict["FEIMRC.next"] = feimrch.next;     //offset from end of header to the first dataset
        dict["FEIMRC.dvid"] = feimrch.dvid;
        dict["FEIMRC.numintegers"] = feimrch.numintegers;
        dict["FEIMRC.numfloats"] = feimrch.numfloats;
        dict["FEIMRC.sub"] = feimrch.sub;
        dict["FEIMRC.zfac"] = feimrch.zfac;
 
        dict["FEIMRC.min2"] = feimrch.min2;
        dict["FEIMRC.max2"] = feimrch.max2;
        dict["FEIMRC.min3"] = feimrch.min3;
        dict["FEIMRC.max3"] = feimrch.max3;
        dict["FEIMRC.min4"] = feimrch.min4;
        dict["FEIMRC.max4"] = feimrch.max4;
 
        dict["FEIMRC.idtype"] = feimrch.idtype;
        dict["FEIMRC.lens"] = feimrch.lens;
        dict["FEIMRC.nd1"] = feimrch.nd1;
        dict["FEIMRC.nd2"] = feimrch.nd2;
        dict["FEIMRC.vd1"] = feimrch.vd1;
        dict["FEIMRC.vd2"] = feimrch.vd2;
 
        char label[32];
 
        for(int i=0; i<9; i++) {        // 9 tilt angles
                sprintf(label, "MRC.tiltangles%d", i);
                dict[string(label)] = feimrch.tiltangles[i];
        }
 
        dict["FEIMRC.zorg"] = feimrch.zorg;
        dict["FEIMRC.xorg"] = feimrch.xorg;
        dict["FEIMRC.yorg"] = feimrch.yorg;
 
        dict["FEIMRC.nlabl"] = feimrch.nlabl;
 
        for (int i = 0; i < feimrch.nlabl; i++) {
                sprintf(label, "MRC.label%d", i);
                dict[string(label)] = string(feimrch.labl[i], MRC_LABEL_SIZE);
        }
 
        /* Read extended image header by specified image index */
        FeiMrcExtHeader feiexth;
 
        portable_fseek(file, sizeof(FeiMrcHeader)+sizeof(FeiMrcExtHeader)*image_index, SEEK_SET);
 
        if (fread(&feiexth, sizeof(FeiMrcExtHeader), 1, file) != 1) {
                throw ImageReadException(filename, "FEI MRC extended header");
        }
 
        dict["FEIMRC.a_tilt"] = feiexth.a_tilt;
        dict["FEIMRC.b_tilt"] = feiexth.b_tilt;
 
        dict["FEIMRC.x_stage"] = feiexth.x_stage;
        dict["FEIMRC.y_stage"] = feiexth.y_stage;
        dict["FEIMRC.z_stage"] = feiexth.z_stage;
 
        dict["FEIMRC.x_shift"] = feiexth.x_shift;
        dict["FEIMRC.y_shift"] = feiexth.y_shift;
 
        dict["FEIMRC.defocus"] = feiexth.defocus;
        dict["FEIMRC.exp_time"] = feiexth.exp_time;
        dict["FEIMRC.mean_int"] = feiexth.mean_int;
        dict["FEIMRC.tilt_axis"] = feiexth.tilt_axis;
 
        dict["FEIMRC.pixel_size"] = feiexth.pixel_size;
        dict["apix_x"] = feiexth.pixel_size *1.0e10;
        dict["apix_y"] = feiexth.pixel_size *1.0e10;
        dict["apix_z"] = feiexth.pixel_size *1.0e10;
        dict["FEIMRC.magnification"] = feiexth.magnification;
        dict["FEIMRC.ht"] = feiexth.ht;
        dict["FEIMRC.binning"] = feiexth.binning;
        dict["FEIMRC.appliedDefocus"] = feiexth.appliedDefocus;
 
        // remainder 16 4-byte floats not used
 
        EXITFUNC;
 
        return 0;
}

◆ read_mrc_header()

int MrcIO::read_mrc_header	(	Dict &	dict,
		int	image_index = `0`,
		const Region *	area = `0`,
		bool	is_3d = `false`
	)

private

Definition at line 428 of file mrcio.cpp.

{
        ENTERFUNC;
 
        if (image_index < 0) {
                image_index = 0;
        }
 
        if (image_index != 0  &&  ! is_stack) {
                throw ImageReadException(filename,
                        "no stack allowed for MRC image. For take 2D slice out of 3D image, "
                        "read the 3D image first, then use get_clip().");
        }
 
        check_region(area, FloatSize(mrch.nx, mrch.ny, mrch.nz), is_new_file, false);
 
        int xlen = 0, ylen = 0, zlen = 0;
 
        EMUtil::get_region_dims(area, mrch.nx, & xlen, mrch.ny, & ylen, mrch.nz, & zlen);
 
        dict["nx"] = xlen;
        dict["ny"] = ylen;
        dict["nz"] = zlen;
        dict["MRC.nx"] = mrch.nx;
        dict["MRC.ny"] = mrch.ny;
        dict["MRC.nz"] = mrch.nz;
 
        dict["datatype"] = to_em_datatype(mrch.mode);
 
        dict["MRC.nxstart"] = mrch.nxstart;
        dict["MRC.nystart"] = mrch.nystart;
        dict["MRC.nzstart"] = mrch.nzstart;
 
        dict["MRC.mx"] = mrch.mx;
        dict["MRC.my"] = mrch.my;
        dict["MRC.mz"] = mrch.mz;
 
        dict["MRC.xlen"] = mrch.xlen;
        dict["MRC.ylen"] = mrch.ylen;
        dict["MRC.zlen"] = mrch.zlen;
 
        dict["MRC.alpha"] = mrch.alpha;
        dict["MRC.beta"] = mrch.beta;
        dict["MRC.gamma"] = mrch.gamma;
 
        dict["MRC.mapc"] = mrch.mapc;
        dict["MRC.mapr"] = mrch.mapr;
        dict["MRC.maps"] = mrch.maps;
 
        dict["MRC.minimum"] = mrch.amin;
        dict["MRC.maximum"] = mrch.amax;
        dict["MRC.mean"] = mrch.amean;
//      dict["minimum"] = mrch.amin;
//      dict["maximum"] = mrch.amax;
//      dict["mean"] = mrch.amean;
 
        dict["MRC.ispg"] = mrch.ispg;
        dict["MRC.nsymbt"] = mrch.nsymbt;
 
        float apx = mrch.xlen / mrch.mx;
        float apy = mrch.ylen / mrch.my;
        float apz = mrch.zlen / mrch.mz;
 
        if (apx > 1000 || apx < 0.01) {
                dict["apix_x"] = 1.0f;
        }
        else {
                dict["apix_x"] = apx;
        }
 
        if (apy > 1000 || apy < 0.01) {
                dict["apix_y"] = 1.0f;
        }
        else {
                dict["apix_y"] = apy;
        }
 
        if (apz > 1000 || apz < 0.01) {
                dict["apix_z"] = 1.0f;
        }
        else {
                dict["apix_z"] = apz;
        }
 
        if (area) {
                dict["origin_x"] = mrch.xorigin + mrch.xlen * area->origin[0];
                dict["origin_y"] = mrch.yorigin + mrch.xlen * area->origin[1];
 
                if (area->get_ndim() == 3 && mrch.nz > 1) {
                        dict["origin_z"] = mrch.zorigin + mrch.xlen * area->origin[2];
                }
                else {
                        dict["origin_z"] = mrch.zorigin;
                }
        }
        else {
                dict["origin_x"] = mrch.xorigin;
                dict["origin_y"] = mrch.yorigin;
                dict["origin_z"] = mrch.zorigin;
        }
 
        if (is_complex_mode()) {
                dict["is_complex"] = 1;
                dict["is_complex_ri"] = 1;
        }
 
        dict["MRC.machinestamp"] = mrch.machinestamp;
 
        dict["MRC.rms"] = mrch.rms;
        dict["sigma"] = mrch.rms;
        dict["MRC.nlabels"] = mrch.nlabels;
 
        char label[32];
 
        for (int i = 0; i < mrch.nlabels; i++) {
                sprintf(label, "MRC.label%d", i);
                dict[string(label)] = string(mrch.labels[i], MRC_LABEL_SIZE);
        }
 
        EMAN1Ctf ctf_;
 
        if (read_ctf(ctf_) == 0) {
                vector<float> vctf = ctf_.to_vector();
                dict["ctf"] = vctf;
        }
 
        if (is_transpose) {
                dict["nx"] = ylen;
                dict["ny"] = xlen;
                dict["MRC.nx"] = mrch.ny;
                dict["MRC.ny"] = mrch.nx;
                dict["MRC.mx"] = mrch.my;
                dict["MRC.my"] = mrch.mx;
                dict["apix_x"] = mrch.ylen / mrch.my;
                dict["apix_y"] = mrch.xlen / mrch.mx;
                dict["origin_x"] = mrch.yorigin;
                dict["origin_y"] = mrch.xorigin;
                dict["MRC.nxstart"] = mrch.nystart;
                dict["MRC.nystart"] = mrch.nxstart;
        }
 
        EXITFUNC;
 
        return 0;
}

◆ swap_header()

void MrcIO::swap_header ( MrcHeader & mrch )

private

Definition at line 1734 of file mrcio.cpp.

{
        ByteOrder::swap_bytes((int *) &mrch, NUM_4BYTES_PRE_MAP);
        ByteOrder::swap_bytes((int *) &mrch.machinestamp, NUM_4BYTES_AFTER_MAP);
}

References EMAN::MrcIO::MrcHeader::machinestamp, mrch, NUM_4BYTES_AFTER_MAP, NUM_4BYTES_PRE_MAP, and EMAN::ByteOrder::swap_bytes().

◆ to_em_datatype()

int MrcIO::to_em_datatype ( int mrcmode )

static

Definition at line 1621 of file mrcio.cpp.

{
        EMUtil::EMDataType e = EMUtil::EM_UNKNOWN;
 
        switch (m) {
        case MRC_CHAR:
                e = EMUtil::EM_CHAR;
                break;
        case MRC_UCHAR:
                e = EMUtil::EM_UCHAR;
                break;
        case MRC_SHORT:
                e = EMUtil::EM_SHORT;
                break;
        case MRC_USHORT:
                e = EMUtil::EM_USHORT;
                break;
        case MRC_SHORT_COMPLEX:
                e = EMUtil::EM_SHORT_COMPLEX;
                break;
        case MRC_FLOAT:
                e = EMUtil::EM_FLOAT;
                break;
        case MRC_FLOAT_COMPLEX:
                e = EMUtil::EM_FLOAT_COMPLEX;
                break;
        default:
                e = EMUtil::EM_UNKNOWN;
        }
 
        return e;
}

References EMAN::EMUtil::EM_CHAR, EMAN::EMUtil::EM_FLOAT, EMAN::EMUtil::EM_FLOAT_COMPLEX, EMAN::EMUtil::EM_SHORT, EMAN::EMUtil::EM_SHORT_COMPLEX, EMAN::EMUtil::EM_UCHAR, EMAN::EMUtil::EM_UNKNOWN, EMAN::EMUtil::EM_USHORT, MRC_CHAR, MRC_FLOAT, MRC_FLOAT_COMPLEX, MRC_SHORT, MRC_SHORT_COMPLEX, MRC_UCHAR, and MRC_USHORT.

Referenced by read_fei_header(), and read_mrc_header().

◆ to_mrcmode()

int MrcIO::to_mrcmode	(	int	em_datatype,
		int	is_complex
	)

static

Definition at line 1654 of file mrcio.cpp.

{
        MrcMode m = MRC_UNKNOWN;
        EMUtil::EMDataType em_type = static_cast < EMUtil::EMDataType > (e);
 
        switch (em_type) {
        case EMUtil::EM_CHAR:
                m = MRC_CHAR;
 
                break;
        case EMUtil::EM_UCHAR:
                m = MRC_UCHAR;
 
                break;
        case EMUtil::EM_USHORT:
                if (is_complex) {
                        m = MRC_SHORT_COMPLEX;
                }
                else {
                        m = MRC_USHORT;
                }
 
                break;
        case EMUtil::EM_SHORT:
                if (is_complex) {
                        m = MRC_SHORT_COMPLEX;
                }
                else {
                        m = MRC_SHORT;
                }
 
                break;
        case EMUtil::EM_SHORT_COMPLEX:
        case EMUtil::EM_USHORT_COMPLEX:
                m = MRC_SHORT_COMPLEX;
 
                break;
        case EMUtil::EM_INT:
        case EMUtil::EM_UINT:
        case EMUtil::EM_FLOAT:
                if (is_complex) {
                        m = MRC_FLOAT_COMPLEX;
                }
                else {
                        m = MRC_FLOAT;
                }
 
                break;
        case EMUtil::EM_FLOAT_COMPLEX:
                m = MRC_FLOAT_COMPLEX;
 
                break;
        default:
                m = MRC_FLOAT;
        }
 
        return m;
}

References EMAN::EMUtil::EM_CHAR, EMAN::EMUtil::EM_FLOAT, EMAN::EMUtil::EM_FLOAT_COMPLEX, EMAN::EMUtil::EM_INT, EMAN::EMUtil::EM_SHORT, EMAN::EMUtil::EM_SHORT_COMPLEX, EMAN::EMUtil::EM_UCHAR, EMAN::EMUtil::EM_UINT, EMAN::EMUtil::EM_USHORT, EMAN::EMUtil::EM_USHORT_COMPLEX, is_complex(), MRC_CHAR, MRC_FLOAT, MRC_FLOAT_COMPLEX, MRC_SHORT, MRC_SHORT_COMPLEX, MRC_UCHAR, MRC_UNKNOWN, and MRC_USHORT.

◆ transpose()

int MrcIO::transpose	(	float *	data,
		int	nx,
		int	ny,
		int	nz
	)		const

private

Definition at line 1747 of file mrcio.cpp.

{
        float * tmp = new float[xlen*ylen];
 
        for(size_t z=0; z<(size_t)zlen; ++z) {
                for(size_t y=0; y<(size_t)ylen; ++y) {
                        for(size_t x=0; x<(size_t)xlen; ++x) {
                                tmp[x*ylen+y] = data[z*xlen*ylen+y*xlen+x];
                        }
                }
 
                std::copy(tmp, tmp+xlen*ylen, data+z*xlen*ylen);
        }
 
        delete [] tmp;
 
        return 0;
}

References copy(), x, and y.

◆ update_stats()

void MrcIO::update_stats	(	void *	data,
		size_t	size
	)

private

This is a utility function used to calculate new min/max/mean/sigma when write MRC file as 16 bit or 8 bit.

It will write new set of min/max/mean/sigma to mrch. this function needs get the output data storage type from mrch.mode.

Definition at line 1406 of file mrcio.cpp.

{
        float  v;       // variable to hold pixel value
        double sum;
        double square_sum;
        double mean;
        double sigma;
        double vv;
        float  min, max;
        
        signed char    *  scdata = NULL;
        unsigned char  *  cdata  = NULL;
        short          *  sdata  = NULL;
        unsigned short *  usdata = NULL;
 
        bool use_schar  = (mrch.mode == MRC_CHAR);
        bool use_uchar  = (mrch.mode == MRC_UCHAR);
        bool use_short  = (mrch.mode == MRC_SHORT || mrch.mode == MRC_SHORT_COMPLEX);
        bool use_ushort = (mrch.mode == MRC_USHORT);
        
        if (use_uchar) {
                max    = 0.0;
                min    = UCHAR_MAX;
                cdata  = (unsigned char *) data;
        }
        else if (use_schar) {
                max    = SCHAR_MIN;
                min    = SCHAR_MAX;
                scdata = (signed char *) data;
        }
        else if (use_short) {
                max    = (float) SHRT_MIN;
                min    = (float) SHRT_MAX;
                sdata  = (short *) data;
        }
        else if (use_ushort) {
                max    = 0.0f;
                min    = (float) USHRT_MAX;
                usdata = (unsigned short *) data;
        }
        else {
                throw InvalidCallException("This function is used to write 8bit/16bit mrc file only.");
        }
 
        sum = 0.0;
 
        for (size_t i = 0; i < size; i++) {
                if (use_uchar) {
                        v = (float) (cdata[i]);
                }
                else if (use_schar) {
                        v = (float) (scdata[i]);
                }
                else if (use_short) {
                        v = (float) (sdata[i]);
                }
                else {
                        v = (float) (usdata[i]);
                }
 
                if (v < min) min = v;
                if (v > max) max = v;
 
                sum = sum + v;
        }
 
        if (size > 0) {
                mean = sum / (double) size;
        }
        else {
                mean = 0.0;
        }
 
        square_sum = 0.0;
 
        for (size_t i = 0; i < size; i++) {
                if (use_uchar) {
                        v = (float) (cdata[i]);
                }
                else if (use_schar) {
                        v = (float) (scdata[i]);
                }
                else if (use_short) {
                        v = (float) (sdata[i]);
                }
                else {
                        v = (float) (usdata[i]);
                }
 
                vv = v - mean;
 
                square_sum = square_sum  +  vv * vv;
        }
 
        if (size > 1) {
                sigma = std::sqrt(square_sum / (double) (size-1));
        }
        else {
                sigma = 0.0;
        }
 
        /* change mrch.amin / amax / amean / rms here */
 
        mrch.amin  = min;
        mrch.amax  = max;
        mrch.amean = (float) mean;
        mrch.rms   = (float) sigma;
        
//      MrcHeader mrch2 = mrch;
//
// endian issue, can't get use_host_endian argument
//      bool opposite_endian = false;
//
//      if (!is_new_file) {
//              if (is_big_endian != ByteOrder::is_host_big_endian()) {
//                      opposite_endian = true;
//              }
//
//              portable_fseek(mrcfile, 0, SEEK_SET);
//      }
//      
//      if (opposite_endian || !use_host_endian) {
//              swap_header(mrch2);
//      }
 
        portable_fseek(file, 0, SEEK_SET);
        
        if (fwrite(& mrch, sizeof(MrcHeader), 1, file) != 1) {
                throw ImageWriteException(filename, "Error writing MRC header to update statistics.");
        }
        
        portable_fseek(file, sizeof(MrcHeader), SEEK_SET);
}

References EMAN::MrcIO::MrcHeader::amax, EMAN::MrcIO::MrcHeader::amean, EMAN::MrcIO::MrcHeader::amin, EMAN::ImageIO::file, EMAN::ImageIO::filename, ImageWriteException, InvalidCallException, EMAN::MrcIO::MrcHeader::mode, MRC_CHAR, MRC_SHORT, MRC_SHORT_COMPLEX, MRC_UCHAR, MRC_USHORT, mrch, portable_fseek(), EMAN::MrcIO::MrcHeader::rms, and sqrt().

◆ write_ctf()

void MrcIO::write_ctf	(	const Ctf &	ctf,
		int	image_index = `0`
	)

virtual

Write CTF data to this image.

Parameters

ctf	Ctf instance storing the CTF data.
image_index	The index of the image to write.

Returns: 0 if OK; 1 if error.

Reimplemented from EMAN::ImageIO.

Definition at line 1569 of file mrcio.cpp.

{
        ENTERFUNC;
 
        init();
 
        string ctf_str = ctf.to_string();
 
        strcpy (mrch.labels[0], CTF_MAGIC);
        strncat(mrch.labels[0], ctf_str.c_str(),
                          MRC_LABEL_SIZE - strlen(CTF_MAGIC) - 1);
 
        rewind(file);
 
        if (fwrite(&mrch, sizeof(MrcHeader), 1, file) != 1) {
                throw ImageWriteException(filename, "write CTF info to header failed");
        }
 
        EXITFUNC;
}

References CTF_MAGIC, ENTERFUNC, EXITFUNC, EMAN::ImageIO::file, EMAN::ImageIO::filename, ImageWriteException, EMAN::ImageIO::init(), EMAN::MrcIO::MrcHeader::labels, MRC_LABEL_SIZE, mrch, and EMAN::Ctf::to_string().

Member Data Documentation

◆

union { ... } EMAN::MrcIO::@9

◆ CTF_MAGIC

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

staticprivate

Definition at line 260 of file mrcio.h.

Referenced by read_ctf(), and write_ctf().

◆ DEFINE_IMAGEIO_FUNC

EMAN::MrcIO::DEFINE_IMAGEIO_FUNC

Definition at line 50 of file mrcio.h.

◆ feimrch

FeiMrcHeader EMAN::MrcIO::feimrch

Definition at line 268 of file mrcio.h.

Referenced by read_fei_header().

◆ is_8_bit_packed

bool EMAN::MrcIO::is_8_bit_packed

private

Definition at line 279 of file mrcio.h.

◆ is_big_endian

bool EMAN::MrcIO::is_big_endian

private

Definition at line 283 of file mrcio.h.

Referenced by MrcIO().

◆ is_new_file

bool EMAN::MrcIO::is_new_file

private

Definition at line 284 of file mrcio.h.

Referenced by read_fei_header(), and read_mrc_header().

◆ is_ri

int EMAN::MrcIO::is_ri

private

Definition at line 282 of file mrcio.h.

◆ is_stack

bool EMAN::MrcIO::is_stack

private

Definition at line 275 of file mrcio.h.

Referenced by read_mrc_header().

◆ is_transpose

bool EMAN::MrcIO::is_transpose

private

Definition at line 285 of file mrcio.h.

Referenced by read_mrc_header().

◆ isFEI

bool EMAN::MrcIO::isFEI

private

Definition at line 272 of file mrcio.h.

◆ mode_size

int EMAN::MrcIO::mode_size

private

Definition at line 264 of file mrcio.h.

◆ mrch

MrcHeader EMAN::MrcIO::mrch

Definition at line 267 of file mrcio.h.

Referenced by MrcIO(), read_ctf(), read_mrc_header(), swap_header(), update_stats(), and write_ctf().

◆ renderbits

int EMAN::MrcIO::renderbits

private

Definition at line 288 of file mrcio.h.

◆ rendermax

float EMAN::MrcIO::rendermax

private

Definition at line 287 of file mrcio.h.

◆ rendermin

float EMAN::MrcIO::rendermin

private

Definition at line 286 of file mrcio.h.

◆ SHORT_CTF_MAGIC

const char * MrcIO::SHORT_CTF_MAGIC = "!$"

staticprivate

Definition at line 261 of file mrcio.h.

◆ stack_size

int EMAN::MrcIO::stack_size

private

Definition at line 276 of file mrcio.h.

Referenced by get_nimg().

◆ use_given_dimensions

bool EMAN::MrcIO::use_given_dimensions

private

Definition at line 280 of file mrcio.h.

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

Classes

Public Member Functions

Static Public Member Functions

Public Attributes

Private Types

Private Member Functions

Static Private Member Functions

Private Attributes

Static Private Attributes

Additional Inherited Members

Detailed Description

Member Enumeration Documentation

◆ anonymous enum

◆ MrcMode

Constructor & Destructor Documentation

◆ MrcIO()

◆ ~MrcIO()

Member Function Documentation

◆ check_swap()

◆ generate_machine_stamp()

◆ get_mode_size()

◆ get_nimg()

◆ is_valid()

◆ read_ctf()

◆ read_fei_header()

◆ read_mrc_header()

◆ swap_header()

◆ to_em_datatype()

◆ to_mrcmode()

◆ transpose()

◆ update_stats()

◆ write_ctf()

Member Data Documentation

◆

◆ CTF_MAGIC

◆ DEFINE_IMAGEIO_FUNC

◆ feimrch

◆ is_8_bit_packed

◆ is_big_endian

◆ is_new_file

◆ is_ri

◆ is_stack

◆ is_transpose

◆ isFEI

◆ mode_size

◆ mrch

◆ renderbits

◆ rendermax

◆ rendermin

◆ SHORT_CTF_MAGIC

◆ stack_size

◆ use_given_dimensions