Micrograph Class Reference

#include <micrograph.h>

Collaboration diagram for Micrograph:

Classes
struct	Point

Public Member Functions
void	clear ()
int	getDatatype () const
int	getDatatypeDetph () const
void	open_micrograph (const FileName &fn_micrograph)
void	close_micrograph ()
const FileName &	micrograph_name ()
void	set_micrograph_name (const FileName &fn)
void	set_ctfparams (const MDRowVec &ctf)
const MDRow &	get_ctfparams ()
void	setStdevFilter (double d)
void	write_coordinates (int label, double minCost, const FileName &fn_coords="")
void	read_coordinates (int label, const FileName &fn_coords)
void	transform_coordinates (const Matrix2D< double > &M)
void	scale_coordinates (const double &c)
int	ParticleNo () const
std::vector< Particle_coords > &	Particles ()
void	get_Particles (std::vector< Particle_coords > &_coords)
void	set_window_size (int _X_window_size, int _Y_window_size)
void	set_transmitance_flag (bool flag_value)
void	setDataType (DataType _datatype)
bool	read_transmitance_flag (void)
void	set_inverse_flag (bool flag_value)
bool	read_inverse_flag (void)
template<typename T >
int	templateScissor (const Image< T > &I, const Particle_coords &P, MultidimArray< double > &result, double Dmin, double Dmax, double scaleX, double scaleY, bool only_check, bool fillBorders)
int	scissor (const Particle_coords &P, MultidimArray< double > &result, double Dmin, double Dmax, double scaleX=1, double scaleY=1, bool only_check=false, bool fillBorders=false)
double	operator() (size_t y, size_t x) const
void	computeDoubleMinMax (double &Dmin, double &Dmax) const
void	set_val (int y, int x, double new_val)
void	produce_all_images (int label, double minCost, const FileName &fn_root, const FileName &fn_image="", double ang=0, bool rmStack=false, bool fillBorders=false, bool extractNoise=false, int Nnoise=-1)
int	search_coord_near (int x, int y, int prec=3) const
void	invalidate_coord (int n)
int	add_coord (int x, int y, int label, double cost)
void	move_last_coord_to (int x, int y)
Particle_coords &	coord (int n)
void	get_coord (int n, Particle_coords &_coords)
int	add_label (const std::string &label)
int	LabelNo ()
std::string &	get_label (int n)
void	get_label (int n, std::string &_label)
void	size (int &_Xdim, int &_Ydim) const
void	resize (int Xdim, int Ydim, const FileName &filename="")
	Set micrograph size (when you do not read the file from disk) More...
void	write (const FileName &fileName, CastWriteMode castMode=CW_CAST)

Public Attributes
size_t	Xdim
size_t	Ydim
size_t	Zdim
size_t	Ndim
Point	point1
Point	point2
std::vector< Particle_coords >	coords

Detailed Description

Micrography class. This class manages a large micrograph on disk. The image is not loaded into memory, that should avoid memory problems

Definition at line 78 of file micrograph.h.

Member Function Documentation

add_coord()

int Micrograph::add_coord	(	int	x,
		int	y,
		int	label,
		double	cost
	)

Add coordinate. It returns the index of the particle added within the coordinate list.

Definition at line 491 of file micrograph.cpp.

{
    struct Particle_coords aux;
    aux.valid = true;
    aux.X = x;
    aux.Y = y;
    aux.label = label;
    aux.cost = cost;
    aux.scoreVar = -1;
    aux.scoreGini = -1;
    coords.push_back(aux);
    return coords.size() - 1;
}

add_label()

int Micrograph::add_label ( const std::string &  label )

inline

Add label. The index assigned to the label is returned

Definition at line 501 of file micrograph.h.

    {
        labels.push_back(label);
        return labels.size() - 1;
    }

clear()

void Micrograph::clear

(

)

Clear

Definition at line 41 of file micrograph.cpp.

{
    single_particle.clear();
    coords.clear();
    fn_coords = fn_micrograph = "";
    X_window_size = Y_window_size = -1;
    fh_micrograph = -1;
    Xdim = Ydim = -1;
    datatype = -1;
    compute_transmitance = false;
    compute_inverse = false;
    IUChar.clear();
    IShort.clear();
    IUShort.clear();
    IInt.clear();
    IUInt.clear();
    IFloat.clear();
}

close_micrograph()

void Micrograph::close_micrograph

(

)

Close micrograpgh. After working with the file, you must close it.

Definition at line 135 of file micrograph.cpp.

{
    switch (datatype)
    {
    case DT_UHalfByte:
    case DT_UChar:
        IUChar.clear();
        break;
    case DT_UShort:
        IUShort.clear();
        break;
    case DT_Short:
        IShort.clear();
        break;
    case DT_Int:
        IInt.clear();
        break;
    case DT_UInt:
        IUInt.clear();
        break;
    case DT_Float:
        IFloat.clear();
        break;
    default:
        std::cerr << "Micrograph::close_micrograph: Unknown datatype "
        << datatype << std::endl;
        REPORT_ERROR(ERR_TYPE_INCORRECT, "ERROR");
        break;
    }
}

computeDoubleMinMax()

void Micrograph::computeDoubleMinMax ( double &  Dmin, double &  Dmax  ) const

inline

Micrograph max min

Definition at line 388 of file micrograph.h.

    {
        if (datatype == DT_UChar || datatype == DT_UHalfByte)
        {
            return IUChar().computeDoubleMinMax(Dmin,Dmax);
        }
        else if (datatype == DT_UShort)
        {
            return IUShort().computeDoubleMinMax(Dmin,Dmax);
        }
        else if (datatype == DT_Short)
        {
            return IShort().computeDoubleMinMax(Dmin,Dmax);
        }
        else if (datatype == DT_UInt)
        {
            return IUInt().computeDoubleMinMax(Dmin,Dmax);
        }
        else if (datatype == DT_Int)
        {
            return IInt().computeDoubleMinMax(Dmin,Dmax);
        }
        else if (datatype == DT_Float)
        {
            return IFloat().computeDoubleMinMax(Dmin,Dmax);
        }

        else
            REPORT_ERROR(ERR_TYPE_INCORRECT, "Micrograph::computeDoubleMinMax::(): unknown datatype");
    }

coord()

Particle_coords& Micrograph::coord ( int  n )

inline

Access to coordinate structure. If the index is out of range then an exception is thrown.

Definition at line 486 of file micrograph.h.

    {
        if (n < 0 || n > ParticleNo())
            REPORT_ERROR(ERR_INDEX_OUTOFBOUNDS, "Micrograph::coord(): index out of range");
        return coords[n];
    }

get_coord()

void Micrograph::get_coord ( int  n, Particle_coords &  _coords  )

inline

Another function for accessing the coordinate structure.

Definition at line 494 of file micrograph.h.

    {
        _coords = coord(n);
    }

get_ctfparams()

const MDRow& Micrograph::get_ctfparams ( )

inline

Return the row with CTF params.

Definition at line 160 of file micrograph.h.

    {
      return ctfRow;
    }

get_label() [1/2]

std::string& Micrograph::get_label ( int  n )

inline

Get a label. An exception is thrown if the index is greater than the number of labels

Definition at line 516 of file micrograph.h.

    {
        if (n < 0 || n > LabelNo())
            REPORT_ERROR(ERR_INDEX_OUTOFBOUNDS, "Micrograph::get_label(): index out of range");
        return labels[n];
    }

get_label() [2/2]

void Micrograph::get_label ( int  n, std::string &  _label  )

inline

Another function for get a lebel.

Definition at line 524 of file micrograph.h.

    {
        _label = get_label(n);
    }

get_Particles()

void Micrograph::get_Particles ( std::vector< Particle_coords > &  _coords )

inline

Another function for getting the particles.

Definition at line 201 of file micrograph.h.

    {
        _coords = coords;
    }

getDatatype()

int Micrograph::getDatatype ( ) const

inline

Get micrograph datatype.

Definition at line 124 of file micrograph.h.

    {
        return datatype;
    }

getDatatypeDetph()

int Micrograph::getDatatypeDetph

(

)

const

Get micrograph datatype.

Definition at line 166 of file micrograph.cpp.

{
    switch (datatype)
    {
    case DT_UHalfByte:
    case DT_UChar:
        return (8 * sizeof(unsigned char));
    case DT_UShort:
        return (8 * sizeof(unsigned short));
    case DT_Short:
        return (8 * sizeof(short));
    case DT_UInt:
        return (8 * sizeof(unsigned int));
    case DT_Int:
        return (8 * sizeof(int));
    case DT_Float:
        return (8 * sizeof(float));
    default:
        std::cerr << "Micrograph::getDatatypeDetph: Unknown datatype "
        << datatype << std::endl;
        REPORT_ERROR(ERR_TYPE_INCORRECT, "ERROR");
        break;
    }
}

invalidate_coord()

void Micrograph::invalidate_coord

(

int

n

)

Remove a coordinate from the coordinate list. An exception is thrown if the index is out of range within the coordinate list

Definition at line 482 of file micrograph.cpp.

{
    if (n < 0 || n >= ParticleNo())
        REPORT_ERROR(ERR_INDEX_OUTOFBOUNDS,
                     "Micrograph::invalidate_coord: Index out of range");
    coords[n].valid = false;
}

LabelNo()

int Micrograph::LabelNo ( )

inline

Number of labels.

Definition at line 508 of file micrograph.h.

    {
        return labels.size();
    }

micrograph_name()

const FileName& Micrograph::micrograph_name ( )

inline

Get micrograph filename.

Definition at line 140 of file micrograph.h.

    {
        return fn_micrograph;
    }

move_last_coord_to()

void Micrograph::move_last_coord_to	(	int	x,
		int	y
	)

Move last coordinate to this position.

Definition at line 506 of file micrograph.cpp.

{
    if (coords.size() > 0)
    {
        coords.back().X = x;
        coords.back().Y = y;
    }
}

open_micrograph()

void Micrograph::open_micrograph

(

const FileName &

fn_micrograph

)

Open micrograph. An exception is thrown if the file is not valid.

Definition at line 61 of file micrograph.cpp.

{
    clear();
    // Micrograph name
    fn_micrograph = _fn_micrograph;
    // Look for micrograph dimensions
    Image<char> auxI = {};
    auxI.read(fn_micrograph, HEADER);

    auxI.getDimensions(Xdim, Ydim, Zdim, Ndim);
    if ((Zdim > 1) || (Ndim > 1))
        REPORT_ERROR(
            ERR_MULTIDIM_DIM,
            "Micrograph::open_micrograph: Only files with a single micrograph may be processed. Error reading " + fn_micrograph);
    auxI.MDMainHeader.getValue(MDL_DATATYPE, datatype);
    __offset = 0;
    auxI.clear();
    //#define DEBUG
#ifdef DEBUG

    std::cerr << "x,y,z,n, datatype : "
    << Xdim << " "
    << Ydim << " "
    << Zdim << " "
    << Ndim << " "
    << datatype << " "
    <<std::endl;
#endif
#undef DEBUG
    //3,4,6
    // Open micrograph and map
    int result;
    switch (datatype)
    {
        case DT_UHalfByte:
    case DT_UChar:
        result = IUChar.readMapped(fn_micrograph, FIRST_IMAGE);
        pixelDesvFilter(IUChar.data, stdevFilter);
        break;
    case DT_UShort:
        result = IUShort.readMapped(fn_micrograph, FIRST_IMAGE);
        pixelDesvFilter(IUShort.data, stdevFilter);
        break;
    case DT_Short:
        result = IShort.readMapped(fn_micrograph, FIRST_IMAGE);
        pixelDesvFilter(IShort.data, stdevFilter);
        break;
    case DT_Int:
        result = IInt.readMapped(fn_micrograph, FIRST_IMAGE);
        pixelDesvFilter(IInt.data, stdevFilter);
        break;
    case DT_UInt:
        result = IUInt.readMapped(fn_micrograph, FIRST_IMAGE);
        pixelDesvFilter(IUChar.data, stdevFilter);
        break;
    case DT_Float:
        result = IFloat.readMapped(fn_micrograph, FIRST_IMAGE);
        pixelDesvFilter(IFloat.data, stdevFilter);
        break;
    default:
        std::cerr << "Micrograph::open_micrograph: Unknown datatype "
        << datatype << std::endl;
        REPORT_ERROR(ERR_TYPE_INCORRECT, "ERROR");
        break;
    }
    //fh_micrograph = open(fn_micrograph.c_str(), O_RDWR, S_IREAD | S_IWRITE);
    if (result < 0)
        REPORT_ERROR(
            ERR_IO_NOTEXIST,
            (std::string)"Micrograph::open_micrograph: There is a "
            "problem opening " + fn_micrograph + "\nCheck that the file has write permission");
}

operator()()

double Micrograph::operator() ( size_t  y, size_t  x  ) const

inline

Pixel access for reading. These coordinates follow the physical Xmipp convention {../../../Extra_Docs/Conventions.html} for coordinates

Definition at line 354 of file micrograph.h.

    {
        if (y < 0 || y >= Ydim || x < 0 || x >= Xdim)
            // COSS: REPORT_ERROR(1, "Micrograph::(): index out of range");
            return 0;
        if (datatype == DT_UChar || datatype == DT_UHalfByte)
        {
            return IMGPIXEL(IUChar,y,x);
        }
        else if (datatype == DT_UShort)
        {
            return IMGPIXEL(IUShort,y,x);
        }
        else if (datatype == DT_Short)
        {
            return IMGPIXEL(IShort,y,x);
        }
        else if (datatype == DT_UInt)
        {
            return IMGPIXEL(IUInt,y,x);
        }
        else if (datatype == DT_Int)
        {
            return IMGPIXEL(IInt,y,x);
        }
        else if (datatype == DT_Float)
        {
            return IMGPIXEL(IFloat,y,x);
        }
        else
            REPORT_ERROR(ERR_TYPE_INCORRECT, "Micrograph::(): unknown datatype");
    }

ParticleNo()

int Micrograph::ParticleNo ( ) const

inline

Particle number. Number of particles in the coordinate list

Definition at line 188 of file micrograph.h.

    {
        return coords.size();
    }

Particles()

std::vector<Particle_coords>& Micrograph::Particles ( )

inline

Particle. Return the list of particles.

Definition at line 195 of file micrograph.h.

    {
        return coords;
    }

produce_all_images()

void Micrograph::produce_all_images	(	int	label,
		double	minCost,
		const FileName &	fn_root,
		const FileName &	fn_image = "",
		double	ang = 0,
		bool	rmStack = false,
		bool	fillBorders = false,
		bool	extractNoise = false,
		int	Nnoise = -1
	)

Produce all single particle images. The file fn_micrograph+".sel" is also generated. The angle is the angle from the Y axis to the tilt axis, angles are positive clockwise. Images are rotated by -ang. If this angle is 0 no rotation is applied.

Definition at line 317 of file micrograph.cpp.

{
    MetaDataVec SF;
    Image<double> I;
    Micrograph *M;

    // Set Source image
    if (fn_image == "")
        M = this;
    else
    {
        M = new Micrograph;
        M->open_micrograph(fn_image/*, swapbyte*/);
        M->set_window_size(X_window_size, Y_window_size);
        M->set_transmitance_flag(compute_transmitance);
        M->set_inverse_flag(compute_inverse);
    }

    // Set scale for particles
    int MXdim;
    int MYdim;
    int thisXdim;
    int thisYdim;
    M->size(MXdim, MYdim);
    this->size(thisXdim, thisYdim);
    double scaleX = (double) MXdim / thisXdim;
    double scaleY = (double) MYdim / thisYdim;

    // Compute max and minimum if compute_transmitance
    // or compute_inverse flags are ON
    double Dmax=0.;
    double Dmin=0.;
    if (compute_transmitance || compute_inverse)
    {
        (*this).computeDoubleMinMax(Dmin, Dmax);

        if (compute_transmitance)
        {
            if (Dmin > 1)
                Dmin = log10(Dmin);
            if (Dmax > 1)
                Dmax = log10(Dmax);
        }
    }
    // Scissor all particles
    if (ang != 0)
        std::cout << "Angle from Y axis to tilt axis " << ang << std::endl
        << "   applying appropriate rotation\n";
    int nmax = ParticleNo();
    int nparticles = nmax;
    if (extractNoise && Nnoise>0)
        nmax=Nnoise;
    FileName fn_aux;
    FileName _ext = fn_rootIn.getFileFormat();
    FileName fn_out;
    FileName fn_root = fn_rootIn.removeFileFormat().removeLastExtension();
    if (fn_rootIn.hasStackExtension())
        fn_out=fn_root.addExtension(_ext);
    else
        fn_out=fn_rootIn.addExtension("stk");

    if (rmStack)
        fn_out.deleteFile();
    size_t ii = 0;
    size_t id;

    Particle_coords Pnoise;
    Pnoise.valid = true;
    Pnoise.label = 0;
    Pnoise.cost = 1;
    Pnoise.scoreVar = -1;
    Pnoise.scoreGini = -1;

    int minNoiseDistance=Y_window_size/2;
    std::vector<Particle_coords> noiseCoords;

    for (int n = 0; n < nmax; n++)
    {
        if (coords[n].valid && coords[n].cost > minCost && coords[n].label == label)
        {
            fn_aux.compose(++ii, fn_out);
            id = SF.addObject();
            // If the ctfRow was set, copy the info to images metadata
            if (ctfRow.containsLabel(MDL_CTF_DEFOCUSU))
                SF.setRow(ctfRow, id);
            SF.setValue(MDL_IMAGE, fn_aux, id);
            SF.setValue(MDL_MICROGRAPH, M->fn_micrograph, id);
            SF.setValue(MDL_XCOOR, coords[n].X, id);
            SF.setValue(MDL_YCOOR, coords[n].Y, id);
            if (coords[n].scoreVar>0)
            {
                SF.setValue(MDL_SCORE_BY_VAR, coords[n].scoreVar, id);
                SF.setValue(MDL_SCORE_BY_GINI, coords[n].scoreGini, id);
            }
            bool t=false;
            if (extractNoise)
            {
                // Look for coordinate that is away from the rest of coordinates
                bool found=false;
                while (!found)
                {
                    Pnoise.X=int(rnd_unif(X_window_size,thisXdim-X_window_size));
                    Pnoise.Y=int(rnd_unif(Y_window_size,thisYdim-Y_window_size));
                    found=true;
                    for (int nn=0; nn<nparticles; nn++)
                    {
                        if (std::abs(Pnoise.X-coords[nn].X)<minNoiseDistance && std::abs(Pnoise.Y-coords[nn].Y)<minNoiseDistance)
                        {
                            found=false;
                            break;
                        }
                    }
                }
                noiseCoords.push_back(Pnoise);
                t = M->scissor(Pnoise, I(), Dmin, Dmax, scaleX, scaleY, false, fillBorders);
            }
            else
                t = M->scissor(coords[n], I(), Dmin, Dmax, scaleX, scaleY, false, fillBorders);
            if (!t)
            {
                std::cout << "Particle " << fn_aux
                << " is very near the border, "
                << "corresponding image is set to blank\n";
                SF.setValue(MDL_ENABLED, -1, id);
            }
            else
                SF.setValue(MDL_ENABLED, 1, id);
            //  if (ang!=0) I().rotate(-ang);
            I.write(fn_out, ii, true, WRITE_APPEND);
        }
    }
    SF.write(fn_out.withoutExtension() + ".xmd");


    // Free source image??
    if (fn_image != "")
    {
        M->close_micrograph();
        delete M;
    }

    if (extractNoise)
    {
        coords.clear();
        coords=noiseCoords;
    }
}

read_coordinates()

void Micrograph::read_coordinates	(	int	label,
		const FileName &	fn_coords
	)

Read coordinates from disk. Coordinates are read into the selected family, the rest of families are untouched as well as the coordinates already belonging to this family

Definition at line 216 of file micrograph.cpp.

{
    std::ifstream fh;
    int line_no = 0;
    std::string line;

    fn_coords = _fn_coords;

    MetaDataVec MD;
    MD.read(fn_coords);
    line_no = MD.size();

    // Resize coordinate list and read
    coords.reserve(line_no);
    struct Particle_coords aux;
    aux.valid = true;
    aux.label = label;
    aux.cost = 1;
    aux.scoreVar = -1;
    aux.scoreGini = -1;

    for (size_t objId : MD.ids())
    {
        MD.getValue(MDL_XCOOR, aux.X, objId); //aux.X=x;
        MD.getValue(MDL_YCOOR, aux.Y, objId); //aux.Y=y;
        if (MD.containsLabel(MDL_SCORE_BY_VAR))
        {
            MD.getValue(MDL_SCORE_BY_VAR, aux.scoreVar, objId);
            MD.getValue(MDL_SCORE_BY_GINI, aux.scoreGini, objId);
        }
        coords.push_back(aux);
    }
}

read_inverse_flag()

bool Micrograph::read_inverse_flag ( void  )

inline

Get Log flag. When cutting images, the contrast is inverted if inverse flag=true. This function reads it

Definition at line 254 of file micrograph.h.

    {
        return compute_inverse;
    }

read_transmitance_flag()

bool Micrograph::read_transmitance_flag ( void  )

inline

Get Transmitance flag. When cutting images, 1/log10 is computed over the pixel values if transmitance_flag=true. This function reads it Note: if pixel_value=0, no log is computed

Definition at line 235 of file micrograph.h.

    {
        return compute_transmitance;
    }

resize()

void Micrograph::resize	(	int	Xdim,
		int	Ydim,
		const FileName &	filename = ""
	)

Set micrograph size (when you do not read the file from disk)

Definition at line 515 of file micrograph.cpp.

{
    this->Xdim = Xdim;
    this->Ydim = Ydim;
    this->Zdim = 1;
    this->Ndim = 1;
    if (datatype == DT_UChar || datatype == DT_UHalfByte)
    {
        IUChar.data.setMmap(true);
        IUChar.data.resize(1, 1, Ydim, Xdim);
    }
    else if (datatype == DT_UShort)
    {
        IUShort.data.setMmap(true);
        IUShort.data.resize(1, 1, Ydim, Xdim);
    }
    else if (datatype == DT_Short)
    {
        IShort.data.setMmap(true);
        IShort.data.resize(1, 1, Ydim, Xdim);
    }
    else if (datatype == DT_UInt)
    {
        IUInt.data.setMmap(true);
        IUInt.data.resize(1, 1, Ydim, Xdim);
    }
    else if (datatype == DT_Int)
    {
        IInt.data.setMmap(true);
        IInt.data.resize(1, 1, Ydim, Xdim);
    }
    else if (datatype == DT_Float)
    {
        IFloat.data.setMmap(true);
        IFloat.data.resize(1, 1, Ydim, Xdim);
    }
    else
        REPORT_ERROR(ERR_TYPE_INCORRECT, "Unknown datatype");

}

scale_coordinates()

void Micrograph::scale_coordinates

(

const double &

c

)

Multiply coordinates by a constant

Definition at line 270 of file micrograph.cpp.

{
    int imax = coords.size();
    for (int i = 0; i < imax; i++)
    {
        if (coords[i].valid)
        {
            coords[i].X = (int) (coords[i].X * c);
            coords[i].Y = (int) (coords[i].Y * c);
        }
    }

}

scissor()

int Micrograph::scissor	(	const Particle_coords &	P,
		MultidimArray< double > &	result,
		double	Dmin,
		double	Dmax,
		double	scaleX = 1,
		double	scaleY = 1,
		bool	only_check = false,
		bool	fillBorders = false
	)

Scissor. The single particle is selected by an index within the particle coordinate list. If the index is beyond the number of particles ParticleNo , or the selfWindow size is not set (set_window_size ) an exception is thrown.

Make sure that index n represents a valid particle before cutting it

The scale affects the particle position, such that the position cut is pos*scale, but not the selfWindow size.

If only check is true then the particle is not scissored, but the routine only checks if it can be done.

Dmax and Dmin are used to invert the image and or compute the trnasmitance

Returns 0 if an error occurred and 1 if everything is all right

Definition at line 285 of file micrograph.cpp.

{
    if (X_window_size == -1 || Y_window_size == -1)
        REPORT_ERROR(ERR_MULTIDIM_SIZE,
                     "Micrograph::scissor: window size not set");
    if (datatype == DT_UChar || datatype == DT_UHalfByte)
        return templateScissor(IUChar, P, result, Dmin, Dmax, scaleX, scaleY,
                               only_check, fillBorders);
    else if (datatype == DT_UShort)
        return templateScissor(IUShort, P, result, Dmin, Dmax, scaleX, scaleY,
                               only_check, fillBorders);
    else if (datatype == DT_Short)
        return templateScissor(IShort, P, result, Dmin, Dmax, scaleX, scaleY,
                               only_check, fillBorders);
    else if (datatype == DT_UInt)
        return templateScissor(IUInt, P, result, Dmin, Dmax, scaleX, scaleY,
                               only_check, fillBorders);
    else if (datatype == DT_Int)
        return templateScissor(IInt, P, result, Dmin, Dmax, scaleX, scaleY,
                               only_check, fillBorders);
    else if (datatype == DT_Float)
        return templateScissor(IFloat, P, result, Dmin, Dmax, scaleX, scaleY,
                               only_check, fillBorders);
    else
        REPORT_ERROR(ERR_TYPE_INCORRECT,
                     "Micrograph::scissor: unknown datatype");

}

search_coord_near()

int Micrograph::search_coord_near	(	int	x,
		int	y,
		int	prec = 3
	)		const

Search coordinate near a position. By default the precission is set to 3 pixels. The index of the coordinate within the list is returned. Returns -1 if none.

Definition at line 469 of file micrograph.cpp.

{
    int imax = coords.size();
    int prec2 = prec * prec;
    for (int i = 0; i < imax; i++)
        if ((coords[i].X - x) * (coords[i].X - x)
                + (coords[i].Y - y) * (coords[i].Y - y) < prec2
                && coords[i].valid)
            return i;
    return -1;
}

set_ctfparams()

void Micrograph::set_ctfparams ( const MDRowVec &  ctf )

inline

Set the CTF parameters

Definition at line 153 of file micrograph.h.

    {
        ctfRow = ctf;
        ctfRow.detach();
    }

set_inverse_flag()

void Micrograph::set_inverse_flag ( bool  flag_value )

inline

Set Log flag. When cutting images, the contrast is inverted if inverse flag is true.

Definition at line 244 of file micrograph.h.

    {
        compute_inverse =
            flag_value;
    }

set_micrograph_name()

void Micrograph::set_micrograph_name ( const FileName &  fn )

inline

Set micrograph filename.

Definition at line 146 of file micrograph.h.

    {
        fn_micrograph = fn;
    }

set_transmitance_flag()

void Micrograph::set_transmitance_flag ( bool  flag_value )

inline

Set Transmitance flag. When cutting images, 1/log10 is computed over the pixel values if this transmitance_flag=true. This function sets it Note: if pixel_value=0, no log is computed

Definition at line 220 of file micrograph.h.

    {
        compute_transmitance =
            flag_value;
    }

set_val()

void Micrograph::set_val ( int  y, int  x, double  new_val  )

inline

Pixel access for writing.

Definition at line 422 of file micrograph.h.

    {
        if (datatype == DT_UChar || datatype == DT_UHalfByte)
        {
            IMGPIXEL(IUChar,y,x) = (unsigned char) new_val;
        }
        else if (datatype == DT_UShort)
        {
            IMGPIXEL(IUShort,y,x) = (unsigned short) new_val;
        }
        else if (datatype == DT_Short)
        {
            IMGPIXEL(IShort,y,x) = (short) new_val;
        }
        else if (datatype == DT_UInt)
        {
            IMGPIXEL(IUInt,y,x) = (unsigned int) new_val;
        }
        else if (datatype == DT_Int)
        {
            IMGPIXEL(IInt,y,x) = (int) new_val;
        }
        else if (datatype == DT_Float)
        {
            IMGPIXEL(IFloat,y,x) = (float) new_val;
        }

        else
            REPORT_ERROR(ERR_TYPE_INCORRECT, "Micrograph::set_val::(): unknown datatype");

    }

set_window_size()

void Micrograph::set_window_size ( int  _X_window_size, int  _Y_window_size  )

inline

Set selfWindow size. This selfWindow is set upon each coordinate and is used to cut all images.

Definition at line 209 of file micrograph.h.

    {
        X_window_size = _X_window_size;
        Y_window_size = _Y_window_size;
    }

setDataType()

void Micrograph::setDataType ( DataType  _datatype )

inline

Definition at line 226 of file micrograph.h.

    {
        datatype = _datatype;
    }

setStdevFilter()

void Micrograph::setStdevFilter ( double  d )

inline

Definition at line 165 of file micrograph.h.

    {
        stdevFilter=d;
    }

size()

void Micrograph::size ( int &  _Xdim, int &  _Ydim  ) const

inline

Return micrograph size

Definition at line 530 of file micrograph.h.

    {
        _Xdim = Xdim;
        _Ydim = Ydim;
    }

templateScissor()

template<typename T >

int Micrograph::templateScissor ( const Image< T > &  I, const Particle_coords &  P, MultidimArray< double > &  result, double  Dmin, double  Dmax, double  scaleX, double  scaleY, bool  only_check, bool  fillBorders  )

inline

Templated scissor function. This is the one actually doing the work

Definition at line 263 of file micrograph.h.

    {
        result.initZeros(Y_window_size, X_window_size);
        int _i0 = ROUND(scaleY * P.Y) + FIRST_XMIPP_INDEX(Y_window_size);
        int _iF = ROUND(scaleY * P.Y) + LAST_XMIPP_INDEX(Y_window_size);
        int _j0 = ROUND(scaleX * P.X) + FIRST_XMIPP_INDEX(X_window_size);
        int _jF = ROUND(scaleX * P.X) + LAST_XMIPP_INDEX(X_window_size);
        int retval = 1;
        double irange=1.0/(Dmax - Dmin);

        if (!fillBorders && (_i0 < 0 || _iF >= Ydim || _j0 < 0 || _jF >= Xdim))
            retval = 0;
        else
            if (!only_check)
            {

                for (int i = _i0, i_i0=0; i <= _iF; i++, i_i0++)
                {
                    int ifrom=i;
                    if (fillBorders)
                    {
                        if (ifrom<0)
                            ifrom=0;
                        else if (ifrom>=Ydim)
                            ifrom=Ydim-1;
                    }
                    for (int j=_j0, j_j0=0; j<=_jF; j++, j_j0++)
                    {
                        int jfrom=j;
                        if (fillBorders)
                        {
                            if (jfrom<0)
                                jfrom=0;
                            else if (jfrom>=Xdim)
                                jfrom=Xdim-1;
                        }
                        double val=IMGPIXEL(I,ifrom,jfrom);
                        if (compute_transmitance)
                        {
                            double temp;
                            if (val < 1)
                                temp = val;
                            else
                                temp = log10(val);
                            if (compute_inverse)
                                A2D_ELEM(result,i_i0, j_j0) = (Dmax - temp) * irange;
                            else
                                A2D_ELEM(result,i_i0, j_j0) = (temp - Dmin) * irange;
                        }
                        else
                        {
                            if (compute_inverse)
                                A2D_ELEM(result, i_i0, j_j0) = (Dmax - val) * irange;
                            else
                                A2D_ELEM(result, i_i0, j_j0) = val;
                        }
                    }
                }
            }
        return retval;
    }

transform_coordinates()

void Micrograph::transform_coordinates

(

const Matrix2D< double > &

M

)

Transform all coordinates according to a 3x3 transformation matrix

Definition at line 251 of file micrograph.cpp.

{
    Matrix1D<double> m(3);
    SPEED_UP_temps012;

    int imax = coords.size();
    for (int i = 0; i < imax; i++)
    {
        if (coords[i].valid)
        {
            VECTOR_R3(m, coords[i].X, coords[i].Y, 1);
            M3x3_BY_V3x1(m, M, m);
            coords[i].X = (int) XX(m);
            coords[i].Y = (int) YY(m);
        }
    }
}

write()

void Micrograph::write	(	const FileName &	fileName,
		CastWriteMode	castMode = CW_CAST
	)

Write micrograph. Set adjust to true if the values should be scaled within the minimum and maximum of the output range. Ex: m.write(fn8bits+"%uint8");

Definition at line 555 of file micrograph.cpp.

{
    if (datatype == DT_UChar)
    {
        IUChar.write(fileName, FIRST_IMAGE, false, WRITE_OVERWRITE, castMode);
    }
    else if (datatype == DT_UHalfByte)
    {
        REPORT_ERROR(ERR_TYPE_INCORRECT,
                     "Micrograph::set_val::(): non supported datatype UHalfByte");
    }
    else if (datatype == DT_UShort)
    {
        IUShort.write(fileName, FIRST_IMAGE, false, WRITE_OVERWRITE, castMode);
    }
    else if (datatype == DT_Short)
    {
        IShort.write(fileName, FIRST_IMAGE, false, WRITE_OVERWRITE, castMode);
    }
    else if (datatype == DT_UInt)
    {
        IUInt.write(fileName, FIRST_IMAGE, false, WRITE_OVERWRITE, castMode);
    }
    else if (datatype == DT_Int)
    {
        IInt.write(fileName, FIRST_IMAGE, false, WRITE_OVERWRITE, castMode);
    }
    else if (datatype == DT_Float)
    {
        IFloat.write(fileName, FIRST_IMAGE, false, WRITE_OVERWRITE, castMode);
    }
    else
        REPORT_ERROR(ERR_TYPE_INCORRECT,
                     "Micrograph::set_val::(): unknown datatype");

}

write_coordinates()

void Micrograph::write_coordinates	(	int	label,
		double	minCost,
		const FileName &	fn_coords = ""
	)

Save coordinates to disk.

Definition at line 192 of file micrograph.cpp.

{
    std::ofstream fh;
    if (_fn_coords != "")
        fn_coords = _fn_coords;

    MetaDataVec MD;
    MD.setComment((std::string) "Selected Coordinates for file " + fn_coords);
    int imax = coords.size();
    for (int i = 0; i < imax; i++)
    {
        if (coords[i].valid && coords[i].cost > minCost
                && coords[i].label == label)
        {
            size_t id = MD.addObject();
            MD.setValue(MDL_XCOOR, coords[i].X, id);
            MD.setValue(MDL_YCOOR, coords[i].Y, id);
        }
    }
    MD.write(fn_coords);
}

Member Data Documentation

coords

std::vector<Particle_coords> Micrograph::coords

Definition at line 118 of file micrograph.h.

Ndim

size_t Micrograph::Ndim

Definition at line 115 of file micrograph.h.

point1

Point Micrograph::point1

Definition at line 116 of file micrograph.h.

point2

Point Micrograph::point2

Definition at line 117 of file micrograph.h.

Xdim

size_t Micrograph::Xdim

Definition at line 112 of file micrograph.h.

Ydim

size_t Micrograph::Ydim

Definition at line 113 of file micrograph.h.

Zdim

size_t Micrograph::Zdim

Definition at line 114 of file micrograph.h.

---

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

• xmipp/libraries/data/micrograph.h
• xmipp/libraries/data/micrograph.cpp