Mask Class Reference

#include <mask.h>

Collaboration diagram for Mask:

Public Member Functions
void	readParams (XmippProgram *program)
	Mask (int _allowed_data_type=ALL_KINDS)
void	clear ()
void	read (int argc, const char **argv)
void	show () const
void	usage () const
void	write_mask (const FileName &fn)
int	datatype ()
void	resize (size_t Xdim)
void	resize (size_t Ydim, size_t Xdim)
void	resize (size_t Zdim, size_t Ydim, size_t Xdim)
template<typename T >
void	resize (const MultidimArray< T > &m)
void	generate_mask (bool apply_geo=false)
void	generate_mask (size_t Zdim, size_t Ydim, size_t Xdim)
void	generate_mask (int Ydim, int Xdim, bool apply_geo=false)
void	generate_mask (int Xdim)
template<typename T >
void	generate_mask (const MultidimArray< T > &m, bool apply_geo=false)
template<typename T >
void	apply_mask (const MultidimArray< T > &I, MultidimArray< T > &result, T subs_val=0, bool apply_geo=false)
template<typename T >
void	produce_vector (const MultidimArray< T > &I, MultidimArray< T > &result)
const MultidimArray< int > &	get_binary_mask () const
MultidimArray< int > &	get_binary_mask ()
void	set_binary_mask (MultidimArray< int > &_imask)
const MultidimArray< double > &	get_cont_mask () const
MultidimArray< double > &	get_cont_mask ()
void	set_cont_mask (MultidimArray< double > &_dmask)
void	force_to_be_continuous ()
void	force_to_be_binary ()

Static Public Member Functions
static void	defineParams (XmippProgram *program, int allowed_data_types=ALL_KINDS, const char *prefix=nullptr, const char *comment=nullptr, bool moreOptions=false)

Public Attributes
int	type
int	mode
double	R1
double	R2
double	pix_width
int	blob_order
double	blob_radius
double	blob_alpha
double	H
double	sigma
double	omega
int	Xrect
int	Yrect
int	Zrect
double	z0
double	y0
double	x0
int	smin
int	smax
std::string	quadrant
FileName	fn_mask
Matrix2D< double >	mask_geo
int	allowed_data_types
MultidimArray< int >	imask
MultidimArray< double >	dmask
std::string	mask_type

Detailed Description

Parameters for a general Mask.

This class contains all parameters needed to generate masks. The class can read parameters from the command line.

To read a mask from a file within a program do the following

Mask mask;
mask.type = READ_BINARY_MASK;
mask.fn_mask = "...";
mask.generate_2Dmask();

mask.apply(input_Matrix2D, output_Matrix2D);

To generate a geometric mask within a program do the following:

Mask mask;

// Define an spherical mask of radius 32 (the active part is
// within the sphere)
mask.type = BINARY_CIRCULAR_MASK;
mask.mode = INNER_MASK;
mask.R1 = 32;

// resize the mask after this pattern
mask.resize(input_Matrix2D);

// Really generate the mask. It is stored internally
mask.generate_2Dmask();

// Apply the mask to some image
mask.apply_mask(input_Matrix2D, output_Matrix2D);

To read a mask from the command line:

Mask mask;
mask.read(argc, argv);
mask.resize(Ydim, Xdim);
mask.generate_2Dmask();
Mask.apply_mask(input_Matrix2D, output_Matrix2D);

Definition at line 360 of file mask.h.

Constructor & Destructor Documentation

Mask()

Mask::Mask

(

int

_allowed_data_type = ALL_KINDS

)

Constructors Allowed data types are ALL_KINDS, INT_MASK and DOUBLE_MASK used with | .

Definition at line 634 of file mask.cpp.

{
    clear();
    allowed_data_types = _allowed_data_types;
}

Member Function Documentation

apply_mask()

template<typename T >

void Mask::apply_mask ( const MultidimArray< T > &  I, MultidimArray< T > &  result, T  subs_val = 0, bool  apply_geo = false  )

inline

Apply mask to image subs_val is the substitute value in case of binary masks

Definition at line 635 of file mask.h.

    {
        switch (datatype())
        {
        case INT_MASK:
            if (apply_geo)
                apply_geo_binary_2D_mask(imask, mask_geo);

            apply_binary_mask(imask, I, result, subs_val);
            break;

        case DOUBLE_MASK:
            if (apply_geo)
                apply_geo_cont_2D_mask(dmask, mask_geo);

            apply_cont_mask(dmask, I, result);
            break;
        }
    }

clear()

void Mask::clear

(

)

Clear

Definition at line 641 of file mask.cpp.

{
    type = NO_MASK;
    mode = INNER_MASK;
    H = R1 = R2 = sigma = 0;
    imask.clear();
    dmask.clear();
    allowed_data_types = 0;
    fn_mask = "";
    x0 = y0 = z0 = 0;
}

datatype()

int Mask::datatype ( )

inline

Return the type of the mask. INT_MASK, DOUBLE_MASK

Definition at line 544 of file mask.h.

    {
        if (type == BINARY_CIRCULAR_MASK || type == BINARY_CROWN_MASK ||
            type == BINARY_CYLINDER_MASK || type == BINARY_FRAME_MASK ||
            type == BINARY_TUBE ||
            type == NO_MASK || type == READ_BINARY_MASK ||
            type == BINARY_DWT_CIRCULAR_MASK || type == BINARY_CONE_MASK)
            return INT_MASK;

        else if (type == GAUSSIAN_MASK || type == RAISED_COSINE_MASK ||
                 type == SINC_MASK || type == SINC_BLACKMAN_MASK ||
                 type == BLACKMAN_MASK || type == RAISED_CROWN_MASK ||
                 type == BINARY_WEDGE_MASK || type == BLOB_CIRCULAR_MASK ||
                 type == BLOB_CROWN_MASK|| type == READ_REAL_MASK)
            return DOUBLE_MASK;

        return 0;
    }

defineParams()

void Mask::defineParams ( XmippProgram *  program, int  allowed_data_types = ALL_KINDS, const char *  prefix = nullptr, const char *  comment = nullptr, bool  moreOptions = false  )

static

Definition at line 1203 of file mask.cpp.

{
    char tempLine[256];
    char tempLine2[512];

    char advanced=' ';
    if (moreOptions)
        advanced='+';
    if(prefix == nullptr)
        sprintf(tempLine, "  [--mask%c <mask_type=circular>] ",advanced);
    else
        sprintf(tempLine,"%s --mask%c <mask_type=circular> ", prefix,advanced);
    if (comment != nullptr)
        sprintf(tempLine2, "%s : %s", tempLine, comment);
    else
        strcpy(tempLine2,tempLine);

    program->addParamsLine(tempLine2);
    program->addParamsLine("        where <mask_type> ");
    // program->addParamsLine("== INT MASK ==");
    if (allowed_data_types & INT_MASK)
    {
        program->addParamsLine("         circular <R>        : circle/sphere mask");
        program->addParamsLine("                :if R>0 => outside R");
        program->addParamsLine("                :if R<0 => inside  R");
        program->addParamsLine("         DWT_circular <R> <smin> <smax>: circle/sphere mask");
        program->addParamsLine("                : smin and smax define the scales to be kept");
        program->addParamsLine("         rectangular <Xrect> <Yrect> <Zrect=-1>: 2D or 3D rectangle");
        program->addParamsLine("                                         :if X,Y,Z > 0 => outside rectangle");
        program->addParamsLine("                                          :if X,Y,Z < 0 => inside rectangle");
        program->addParamsLine("         crown <R1> <R2>    : 2D or 3D crown");
        program->addParamsLine("                                          :if R1,R2 > 0 => outside crown");
        program->addParamsLine("                                          :if R1,R2 < 0 => inside crown");
        program->addParamsLine("         cylinder <R> <H>   : 2D circle or 3D cylinder");
        program->addParamsLine("                                         :if R,H > 0 => outside cylinder");
        program->addParamsLine("                                          :if R,H < 0 => inside cylinder");
        program->addParamsLine("         tube <R1> <R2> <H> : 3D tube");
        program->addParamsLine("                                          :if R1,R2,H > 0 => outside tube");
        program->addParamsLine("                                          :if R1,R2,H < 0 => inside tube");
        program->addParamsLine("         cone <theta>       : 3D cone (parallel to Z) ");
        program->addParamsLine("                                          :if theta > 0 => outside cone");
        program->addParamsLine("                                         :if theta < 0 => inside cone");
        program->addParamsLine("         wedge <th0> <thF>  : 3D missing-wedge mask for data ");
        program->addParamsLine("                                          :collected between tilting angles ");
        program->addParamsLine("                                          :th0 and thF (around the Y-axis) ");
        program->addParamsLine("         binary_file <binary_file>      : Read from file and cast to binary");
    }
    //program->addParamsLine("== DOUBLE MASK ==");
    if (allowed_data_types & DOUBLE_MASK)
    {
        program->addParamsLine("         real_file <float_file>       : Read from file and do not cast");
        program->addParamsLine("         gaussian <sigma>   : 2D or 3D gaussian");
        program->addParamsLine("                              :if sigma > 0 => outside gaussian");
        program->addParamsLine("                              : if sigma < 0 => inside gaussian");
        program->addParamsLine("         raised_cosine <R1> <R2>: 2D or 3D raised_cosine");
        program->addParamsLine("                              : if R1,R2 > 0 => outside sphere");
        program->addParamsLine("                              : if R1,R2 < 0 => inside sphere");
        program->addParamsLine("         raised_crown <R1> <R2> <pixwidth>: 2D or 3D raised_crown");
        program->addParamsLine("                              : if R1,R2 > 0 => outside sphere");
        program->addParamsLine("                              : if R1,R2 < 0 => inside sphere");
        program->addParamsLine("         blob_circular <R1> <blob_radius>: 2D or 3D blob circular");
        program->addParamsLine("                              : if blob_radius > 0 => outside sphere");
        program->addParamsLine("                              : if blob_radius < 0 => inside sphere");
        program->addParamsLine("         blob_crown <R1> <R2> <blob_radius>: 2D or 3D blob_crown");
        program->addParamsLine("                              : if blob_radius > 0 => outside sphere");
        program->addParamsLine("                              : if blob_radius < 0 => inside sphere");
        program->addParamsLine("         blackman           : 2D or 3D Blackman mask");
        program->addParamsLine("                             :  always inside blackman");
        program->addParamsLine("         sinc <w>          : 2D or 3D sincs");
        program->addParamsLine("                             :  if w > 0 => outside sinc");
        program->addParamsLine("                             :  if w < 0 => inside sinc");
        sprintf(tempLine, "   [ -m%c <blob_order=2>]       : Order of blob",advanced);
        program->addParamsLine(tempLine);
        sprintf(tempLine, "   [ -a%c <blob_alpha=10.4>]    : Alpha of blob",advanced);
        program->addParamsLine(tempLine);
    }
    sprintf(tempLine, "   [--center%c <x0=0> <y0=0> <z0=0>]: mask center",advanced);
    program->addParamsLine(tempLine);
}

force_to_be_binary()

void Mask::force_to_be_binary ( )

inline

Force to be binary

This function is used when you need a double mask as a binary matrix.

Definition at line 763 of file mask.h.

    {
        if (datatype() == DOUBLE_MASK)
        {
            typeCast(dmask, imask);
        }
    }

force_to_be_continuous()

void Mask::force_to_be_continuous ( )

inline

Force to be continuous

This function is used when you need a binary mask as a double matrix.

Definition at line 751 of file mask.h.

    {
        if (datatype() == INT_MASK)
        {
            typeCast(imask, dmask);
        }
    }

generate_mask() [1/5]

void Mask::generate_mask

(

bool

apply_geo = false

)

Generate mask for a resized signal It is supposed that the image is already resized and with its logical origin set.

Definition at line 1577 of file mask.cpp.

{
    ImageGeneric img;
    Matrix2D<double> AA(4, 4);
    AA.initIdentity();
    blobtype blob;
    if (type==BLOB_CIRCULAR_MASK || type==BLOB_CROWN_MASK)
    {
        blob.radius = blob_radius;
        blob.order = blob_order;
        blob.alpha = blob_alpha;
    }

    switch (type)
    {
    case NO_MASK:
        imask.initConstant(1);
        break;
    case BINARY_CIRCULAR_MASK:
        BinaryCircularMask(imask, R1, mode, x0, y0, z0);
        break;
    case BINARY_DWT_CIRCULAR_MASK:
        BinaryDWTCircularMask2D(imask, R1, smin, smax, quadrant);
        break;
    case BINARY_DWT_SPHERICAL_MASK:
        BinaryDWTSphericalMask3D(imask, R1, smin, smax, quadrant);
        break;
    case BINARY_CROWN_MASK:
        BinaryCrownMask(imask, R1, R2, mode, x0, y0, z0);
        break;
    case BINARY_CYLINDER_MASK:
        BinaryCylinderMask(imask, R1, H, mode, x0, y0, z0);
        break;
    case BINARY_TUBE:
        BinaryTubeMask(imask, R1, R2, H,  mode, x0, y0, z0);
        break;
    case BINARY_FRAME_MASK:
        BinaryFrameMask(imask, Xrect, Yrect, Zrect, mode, x0, y0, z0);
        break;
    case BINARY_CONE_MASK:
        BinaryConeMask(imask, R1, mode);
        break;
    case BINARY_WEDGE_MASK:
        BinaryWedgeMask(imask, R1, R2, AA);
        break;
    case GAUSSIAN_MASK:
        GaussianMask(dmask, sigma, mode, x0, y0, z0);
        break;
    case RAISED_COSINE_MASK:
        RaisedCosineMask(dmask, R1, R2, mode, x0, y0, z0);
        break;
    case RAISED_CROWN_MASK:
        RaisedCrownMask(dmask, R1, R2, pix_width, mode, x0, y0, z0);
        break;
    case BLOB_CIRCULAR_MASK:
        BlobCircularMask(dmask, R1, blob, mode, x0, y0, z0);
        break;
    case BLOB_CROWN_MASK:
        BlobCrownMask(dmask, R1, R2, blob, mode, x0, y0, z0);
        break;
    case BLACKMAN_MASK:
        BlackmanMask(dmask, mode, x0, y0, z0);
        break;
    case SINC_MASK:
        SincMask(dmask, omega, mode, x0, y0, z0);
        break;
    case READ_BINARY_MASK:
        img.readMapped(fn_mask);
        img().getImage(imask);
        imask.setXmippOrigin();
        break;
    case READ_REAL_MASK://ROB
        img.readMapped(fn_mask);
        img().getImage(dmask);
        dmask.setXmippOrigin();
        break;
    default:
        REPORT_ERROR(ERR_VALUE_INCORRECT, "MaskProgram::generate_mask: Unknown mask type :"
                     + integerToString(type));
    }

    if (apply_geo)
    {
        switch (datatype())
        {
        case INT_MASK:
            if (ZSIZE(imask) > 1)
                REPORT_ERROR(ERR_NOT_IMPLEMENTED,"Error: apply_geo only implemented for 2D masks");
            apply_geo_binary_2D_mask(imask, mask_geo);
            break;
        case DOUBLE_MASK:
            if (ZSIZE(dmask) > 1)
                REPORT_ERROR(ERR_NOT_IMPLEMENTED,"Error: apply_geo only implemented for 2D masks");
            apply_geo_cont_2D_mask(dmask, mask_geo);
            break;
        }
    }
}

generate_mask() [2/5]

void Mask::generate_mask ( size_t  Zdim, size_t  Ydim, size_t  Xdim  )

inline

Generate mask for an empty signal

Definition at line 600 of file mask.h.

    {
        resize(Zdim, Ydim, Xdim);
        generate_mask();
    }

generate_mask() [3/5]

void Mask::generate_mask ( int  Ydim, int  Xdim, bool  apply_geo = false  )

inline

Generate mask for an empty signal

Definition at line 608 of file mask.h.

    {
        resize(Ydim, Xdim);
        generate_mask(apply_geo);
    }

generate_mask() [4/5]

void Mask::generate_mask ( int  Xdim )

inline

Generate mask for an empty signal

Definition at line 616 of file mask.h.

    {
        resize(Xdim);
        generate_mask();
    }

generate_mask() [5/5]

template<typename T >

void Mask::generate_mask ( const MultidimArray< T > &  m, bool  apply_geo = false  )

inline

Generate mask for a signal following a pattern

Definition at line 625 of file mask.h.

    {
        resize(m);
        generate_mask(apply_geo);
    }

get_binary_mask() [1/2]

const MultidimArray< int >& Mask::get_binary_mask ( ) const

inline

Get binary mask

Definition at line 707 of file mask.h.

    {
        return imask;
    }

get_binary_mask() [2/2]

MultidimArray< int >& Mask::get_binary_mask ( )

inline

Get binary mask

Definition at line 714 of file mask.h.

    {
        return imask;
    }

get_cont_mask() [1/2]

const MultidimArray< double >& Mask::get_cont_mask ( ) const

inline

Get continuous mask

Definition at line 728 of file mask.h.

    {
        return dmask;
    }

get_cont_mask() [2/2]

MultidimArray< double >& Mask::get_cont_mask ( )

inline

Get continuous mask

Definition at line 735 of file mask.h.

    {
        return dmask;
    }

produce_vector()

template<typename T >

void Mask::produce_vector ( const MultidimArray< T > &  I, MultidimArray< T > &  result  )

inline

Produce vector from MultidimArray

This function returns a 1D vector with all those voxels for which the mask was greater than 0. If the output vector is of size 0, then it is resized to the right size. Otherwise, it is assumed that it has already the right size. The input volume is assumed to be of the same size as the existing mask.

Definition at line 666 of file mask.h.

    {
        // Resize the output vector
        if (XSIZE(result) == 0)
        {
            int size = 0;
            switch (datatype())
            {
            case INT_MASK:
                FOR_ALL_DIRECT_ELEMENTS_IN_ARRAY3D(imask)
                if (DIRECT_A2D_ELEM(imask, i, j) > 0)
                    size++;
                break;

            case DOUBLE_MASK:
                FOR_ALL_DIRECT_ELEMENTS_IN_ARRAY3D(dmask)
                if (DIRECT_A2D_ELEM(dmask, i, j) > 0)
                    size++;
                break;
            }
            result.initZeros(size);
        }

        int p = 0;
        switch (datatype())
        {
        case INT_MASK:
            FOR_ALL_DIRECT_ELEMENTS_IN_ARRAY3D(imask)
            if (DIRECT_A2D_ELEM(imask, i, j) > 0)
                DIRECT_A1D_ELEM(result, p++) = DIRECT_A3D_ELEM(I, k, i, j);
            break;
        case DOUBLE_MASK:
            FOR_ALL_DIRECT_ELEMENTS_IN_ARRAY3D(dmask)
            if (DIRECT_A2D_ELEM(dmask, i, j) > 0)
                DIRECT_A1D_ELEM(result, p++) = DIRECT_A3D_ELEM(I, k, i, j);
            break;
        }
    }

read()

void Mask::read	(	int	argc,
		const char **	argv
	)

Read from command line An exception is thrown if the read mask is not of an allowed type.

Definition at line 701 of file mask.cpp.

{
    int i = paremeterPosition(argc, argv, "--center");
    if (i != -1)
    {
        if (i + 3 >= argc)
            REPORT_ERROR(ERR_UNCLASSIFIED, "Mask: Not enough parameters after -center");
        x0 = textToFloat(argv[i+1]);
        y0 = textToFloat(argv[i+2]);
        z0 = textToFloat(argv[i+3]);
    }
    else
    {
        x0 = y0 = z0 = 0;
    }

    i = paremeterPosition(argc, argv, "--mask");
    if (i == -1)
    {
        clear();
        return;
    }
    if (i + 1 >= argc)
        REPORT_ERROR(ERR_ARG_MISSING, "MaskProgram: --mask with no mask_type");
    // Circular mask ........................................................
    if (strcmp(argv[i+1], "circular") == 0)
    {
        if (i + 2 >= argc)
            REPORT_ERROR(ERR_ARG_MISSING, "MaskProgram: circular mask with no radius");
        if (!(allowed_data_types & INT_MASK))
            REPORT_ERROR(ERR_ARG_INCORRECT, "MaskProgram: binary masks are not allowed");
        R1 = textToFloat(argv[i+2]);
        if (R1 < 0)
        {
            mode = INNER_MASK;
            R1 = ABS(R1);
        }
        else if (R1 > 0)
            mode = OUTSIDE_MASK;
        else
            REPORT_ERROR(ERR_ARG_INCORRECT, "MaskProgram: circular mask with radius 0");
        type = BINARY_CIRCULAR_MASK;
        // Circular DWT mask ....................................................
    }
    else if (strcmp(argv[i+1], "DWT_circular") == 0)
    {
        if (i + 5 >= argc)
            REPORT_ERROR(ERR_ARG_MISSING, "MaskProgram: DWT circular mask with not enough parameters");
        if (!(allowed_data_types & INT_MASK))
            REPORT_ERROR(ERR_ARG_INCORRECT, "MaskProgram: binary masks are not allowed");
        R1 = ABS(textToFloat(argv[i+2]));
        smin = textToInteger(argv[i+3]);
        smax = textToInteger(argv[i+4]);
        quadrant = argv[i+5];
        type = BINARY_DWT_CIRCULAR_MASK;
        // Rectangular mask .....................................................
    }
    else if (strcmp(argv[i+1], "rectangular") == 0)
    {
        if (i + 3 >= argc)
            REPORT_ERROR(ERR_ARG_MISSING, "MaskProgram: rectangular mask needs at least two dimensions");
        if (!(allowed_data_types & INT_MASK))
            REPORT_ERROR(ERR_ARG_INCORRECT, "MaskProgram: binary masks are not allowed");
        Xrect = textToInteger(argv[i+2]);
        Yrect = textToInteger(argv[i+3]);
        if (i + 4 < argc)
        {
            Zrect = textToInteger(argv[i+4]);
            if (argv[i+4][0] != '-')
                Zrect = ABS(Zrect);
        }
        else
            Zrect = 0;
        if (Xrect < 0 && Yrect < 0 && Zrect <= 0)
        {
            mode = INNER_MASK;
            Xrect = ABS(Xrect);
            Yrect = ABS(Yrect);
            Zrect = ABS(Zrect);
        }
        else if (Xrect > 0 && Yrect > 0 && Zrect >= 0)
            mode = OUTSIDE_MASK;
        else
            REPORT_ERROR(ERR_ARG_INCORRECT, "MaskProgram: cannot determine mode for rectangle");
        type = BINARY_FRAME_MASK;
        // Cone mask ............................................................
    }
    else if (strcmp(argv[i+1], "cone") == 0)
    {
        if (i + 2 >= argc)
            REPORT_ERROR(ERR_ARG_MISSING, "MaskProgram: cone mask needs one angle");
        if (!(allowed_data_types & INT_MASK))
            REPORT_ERROR(ERR_ARG_INCORRECT, "MaskProgram: binary masks are not allowed");
        R1 = textToFloat(argv[i+2]);
        if (R1 < 0)
        {
            mode = INNER_MASK;
            R1 = ABS(R1);
        }
        else
            mode = OUTSIDE_MASK;
        type = BINARY_CONE_MASK;
        // Wedge mask ............................................................
    }
    else if (strcmp(argv[i+1], "wedge") == 0)
    {
        if (i + 3 >= argc)
            REPORT_ERROR(ERR_ARG_MISSING, "MaskProgram: wedge mask needs two angles");
        if (!(allowed_data_types & DOUBLE_MASK))
            REPORT_ERROR(ERR_ARG_INCORRECT, "MaskProgram: binary masks are not allowed");
        R1 = textToFloat(argv[i+2]);
        R2 = textToFloat(argv[i+3]);
        type = BINARY_WEDGE_MASK;
        // Crown mask ...........................................................
    }
    else if (strcmp(argv[i+1], "crown") == 0)
    {
        if (i + 3 >= argc)
            REPORT_ERROR(ERR_ARG_MISSING, "MaskProgram: crown mask needs two radii");
        if (!(allowed_data_types & INT_MASK))
            REPORT_ERROR(ERR_ARG_INCORRECT, "MaskProgram: binary masks are not allowed");
        R1 = textToFloat(argv[i+2]);
        R2 = textToFloat(argv[i+3]);
        if (R1 < 0 && R2 < 0)
        {
            mode = INNER_MASK;
            R1 = ABS(R1);
            R2 = ABS(R2);
        }
        else if (R1 > 0 && R2 > 0)
            mode = OUTSIDE_MASK;
        else
            REPORT_ERROR(ERR_ARG_INCORRECT, "MaskProgram: cannot determine mode for crown");
        type = BINARY_CROWN_MASK;
        // Cylinder mask ........................................................
    }
    else if (strcmp(argv[i+1], "cylinder") == 0)
    {
        if (i + 3 >= argc)
            REPORT_ERROR(ERR_ARG_MISSING, "MaskProgram: cylinder mask needs a radius and a height");
        if (!(allowed_data_types & INT_MASK))
            REPORT_ERROR(ERR_ARG_INCORRECT, "MaskProgram: binary masks are not allowed");
        R1 = textToFloat(argv[i+2]);
        H = textToFloat(argv[i+3]);
        if (R1 < 0 && H < 0)
        {
            mode = INNER_MASK;
            R1 = ABS(R1);
            H = ABS(H);
        }
        else if (R1 > 0 && H > 0)
            mode = OUTSIDE_MASK;
        else
            REPORT_ERROR(ERR_ARG_INCORRECT, "MaskProgram: cannot determine mode for cylinder");
        type = BINARY_CYLINDER_MASK;
        // Gaussian mask ........................................................
    }
    else if (strcmp(argv[i+1], "tube") == 0)
    {
        if (i + 4 >= argc)
            REPORT_ERROR(ERR_ARG_MISSING, "MaskProgram: tube mask needs two radii and a height");
        if (!(allowed_data_types & INT_MASK))
            REPORT_ERROR(ERR_ARG_INCORRECT, "MaskProgram: binary masks are not allowed");
        R1 = textToFloat(argv[i+2]);
        R2 = textToFloat(argv[i+3]);
        H = textToFloat(argv[i+4]);
        if (R1 < 0 && R2 < 0 && H<0)
        {
            mode = INNER_MASK;
            R1 = ABS(R1);
            R2 = ABS(R2);
            H=ABS(H);
        }
        else if (R1 > 0 && R2 > 0 && H>0)
            mode = OUTSIDE_MASK;
        else
            REPORT_ERROR(ERR_ARG_INCORRECT, "MaskProgram: cannot determine mode for crown");
        type = BINARY_TUBE;
        // Cylinder mask ........................................................
    }
    else if (strcmp(argv[i+1], "gaussian") == 0)
    {
        if (i + 2 >= argc)
            REPORT_ERROR(ERR_ARG_MISSING, "MaskProgram: gaussian mask needs a sigma");
        if (!(allowed_data_types & DOUBLE_MASK))
            REPORT_ERROR(ERR_ARG_INCORRECT, "MaskProgram: continuous masks are not allowed");
        sigma = textToFloat(argv[i+2]);
        if (sigma < 0)
        {
            mode = INNER_MASK;
            sigma = ABS(sigma);
        }
        else
            mode = OUTSIDE_MASK;
        type = GAUSSIAN_MASK;
        // Raised cosine mask ...................................................
    }
    else if (strcmp(argv[i+1], "raised_cosine") == 0)
    {
        if (i + 3 >= argc)
            REPORT_ERROR(ERR_ARG_MISSING, "MaskProgram: raised_cosine mask needs two radii");
        if (!(allowed_data_types & INT_MASK))
            REPORT_ERROR(ERR_ARG_INCORRECT, "MaskProgram: continuous masks are not allowed");
        R1 = textToFloat(argv[i+2]);
        R2 = textToFloat(argv[i+3]);
        if (R1 < 0 && R2 < 0)
        {
            mode = INNER_MASK;
            R1 = ABS(R1);
            R2 = ABS(R2);
        }
        else if (R1 > 0 && R2 > 0)
            mode = OUTSIDE_MASK;
        else
            REPORT_ERROR(ERR_ARG_INCORRECT, "MaskProgram: cannot determine mode for raised_cosine");
        type = RAISED_COSINE_MASK;
        // Raised crown mask ....................................................
    }
    else if (strcmp(argv[i+1], "raised_crown") == 0)
    {
        if (i + 4 >= argc)
            REPORT_ERROR(ERR_ARG_MISSING, "MaskProgram: raised_crown mask needs two radii & a width");
        if (!(allowed_data_types & INT_MASK))
            REPORT_ERROR(ERR_ARG_INCORRECT, "MaskProgram: continuous masks are not allowed");
        R1 = textToFloat(argv[i+2]);
        R2 = textToFloat(argv[i+3]);
        pix_width = textToFloat(argv[i+4]);
        if (R1 < 0 && R2 < 0)
        {
            mode = INNER_MASK;
            R1 = ABS(R1);
            R2 = ABS(R2);
        }
        else if (R1 > 0 && R2 > 0)
            mode = OUTSIDE_MASK;
        else
            REPORT_ERROR(ERR_ARG_INCORRECT, "MaskProgram: cannot determine mode for raised_cosine");
        type = RAISED_CROWN_MASK;
        // Blob circular mask ....................................................
    }
    else if (strcmp(argv[i+1], "blob_circular") == 0)
    {
        if (i + 3 >= argc)
            REPORT_ERROR(ERR_ARG_MISSING, "MaskProgram: blob_circular mask needs one radius and a width");
        if (!(allowed_data_types & INT_MASK))
            REPORT_ERROR(ERR_ARG_INCORRECT, "MaskProgram: continuous masks are not allowed");
        R1 = textToFloat(argv[i+2]);
        double aux = textToFloat(argv[i+3]);
        blob_radius= ABS(aux);
        if (aux < 0)
            mode = INNER_MASK;
        else if (aux > 0)
            mode = OUTSIDE_MASK;
        else
            REPORT_ERROR(ERR_ARG_INCORRECT, "MaskProgram: cannot determine mode for blob_circular");
        type = BLOB_CIRCULAR_MASK;
        blob_order= textToInteger(getParameter(argc, argv, "-m", "2"));
        blob_alpha= textToFloat(getParameter(argc, argv, "-a", "10.4"));

        // Raised crown mask ....................................................
    }
    else if (strcmp(argv[i+1], "blob_crown") == 0)
    {
        if (i + 4 >= argc)
            REPORT_ERROR(ERR_ARG_MISSING, "MaskProgram: blob_crown mask needs two radii and a with");
        if (!(allowed_data_types & INT_MASK))
            REPORT_ERROR(ERR_ARG_INCORRECT, "MaskProgram: continuous masks are not allowed");
        R1 = textToFloat(argv[i+2]);
        R2 = textToFloat(argv[i+3]);
        double aux = textToFloat(argv[i+4]);
        blob_radius= ABS(aux);
        if (aux < 0)
            mode = INNER_MASK;
        else if (aux > 0)
            mode = OUTSIDE_MASK;
        else
            REPORT_ERROR(ERR_ARG_INCORRECT, "MaskProgram: cannot determine mode for blob_crown");
        type = BLOB_CROWN_MASK;
        blob_order= textToInteger(getParameter(argc, argv, "-m", "2"));
        blob_alpha= textToFloat(getParameter(argc, argv, "-a", "10.4"));

        // Blackman mask ........................................................
    }
    else if (strcmp(argv[i+1], "blackman") == 0)
    {
        mode = INNER_MASK;
        type = BLACKMAN_MASK;
        // Sinc mask ............................................................
    }
    else if (strcmp(argv[i+1], "sinc") == 0)
    {
        if (i + 2 >= argc)
            REPORT_ERROR(ERR_ARG_MISSING, "MaskProgram: sinc mask needs a frequency");
        if (!(allowed_data_types & INT_MASK))
            REPORT_ERROR(ERR_ARG_INCORRECT, "MaskProgram: binary masks are not allowed");
        omega = textToFloat(argv[i+2]);
        if (omega < 0)
        {
            mode = INNER_MASK;
            omega = ABS(omega);
        }
        else
            mode = OUTSIDE_MASK;
        type = SINC_MASK;
    }
    else if (strcmp(argv[i+1], "binary_file") == 0)
    {
        fn_mask = argv[i+2];
        type = READ_BINARY_MASK;
    }
    else if (strcmp(argv[i+1], "real_file") == 0)
    {
        fn_mask = argv[i+2];
        type = READ_REAL_MASK;
    }
    else
        REPORT_ERROR(ERR_ARG_INCORRECT,"Incorrect mask type");
}

readParams()

void Mask::readParams

(

XmippProgram *

program

)

Definition at line 1284 of file mask.cpp.

{
    x0 = y0 = z0 = 0;
    x0 = program->getDoubleParam("--center",0);
    y0 = program->getDoubleParam("--center",1);
    z0 = program->getDoubleParam("--center",2);
    mask_type = program->getParam("--mask");

    /* Circular mask ........................................................*/
    if (mask_type == "circular")
    {
        if (!(allowed_data_types & INT_MASK))
            REPORT_ERROR(ERR_ARG_INCORRECT, "MaskProgram: binary masks are not allowed");
        R1 = program->getDoubleParam("--mask","circular");
        if (R1 < 0)
        {
            Mask::mode = INNER_MASK;
            R1 = ABS(R1);
        }
        else if (R1 > 0)
            Mask::mode = OUTSIDE_MASK;
        else
            REPORT_ERROR(ERR_ARG_INCORRECT, "MaskProgram: circular mask with radius 0");
        type = BINARY_CIRCULAR_MASK;
    }
    /*// Circular DWT mask ....................................................*/
    else if (mask_type == "DWT_circular")
    {
        if (!(allowed_data_types & INT_MASK))
            REPORT_ERROR(ERR_ARG_INCORRECT, "MaskProgram: binary masks are not allowed");
        R1 = program->getDoubleParam("--mask","DWT_circular",0);
        smin = program->getIntParam("--mask","DWT_circular",1);
        smax = program->getIntParam("--mask","DWT_circular",2);
        quadrant = program->getParam("--mask","DWT_circular",3);
        type = BINARY_DWT_CIRCULAR_MASK;
    }
    /*// Rectangular mask .....................................................*/
    else if (mask_type == "rectangular")
    {
        if (!(allowed_data_types & INT_MASK))
            REPORT_ERROR(ERR_ARG_INCORRECT, "MaskProgram: binary masks are not allowed");
        Xrect = program->getIntParam("--mask","rectangular",0);
        Yrect = program->getIntParam("--mask","rectangular",1);
        Zrect = program->getIntParam("--mask","rectangular",2);
        if (Xrect < 0 && Yrect < 0 && Zrect <= 1)
        {
            Mask::mode = INNER_MASK;
            Xrect = ABS(Xrect);
            Yrect = ABS(Yrect);
            Zrect = ABS(Zrect);
        }
        else if (Xrect > 0 && Yrect > 0 && Zrect >= -1)
            Mask::mode = OUTSIDE_MASK;
        else
            REPORT_ERROR(ERR_ARG_INCORRECT, "MaskProgram: cannot determine mode for rectangle");
        type = BINARY_FRAME_MASK;
    }
    /*// Cone mask ............................................................*/
    else if (mask_type == "cone")
    {
        if (!(allowed_data_types & INT_MASK))
            REPORT_ERROR(ERR_ARG_INCORRECT, "MaskProgram: binary masks are not allowed");
        R1 = program->getDoubleParam("--mask","cone");
        if (R1 < 0)
        {
            Mask::mode = INNER_MASK;
            R1 = ABS(R1);
        }
        else
            Mask::mode = OUTSIDE_MASK;
        type = BINARY_CONE_MASK;
    }
    /*// Wedge mask ............................................................*/
    else if (mask_type == "wedge")
    {
        if (!(allowed_data_types & DOUBLE_MASK))
            REPORT_ERROR(ERR_ARG_INCORRECT, "MaskProgram: binary masks are not allowed");
        R1 = program->getDoubleParam("--mask","wedge",0);
        R2 = program->getDoubleParam("--mask","wedge",1);
        type = BINARY_WEDGE_MASK;
    }
    /*// Crown mask ...........................................................*/
    else if (mask_type == "crown")
    {
        if (!(allowed_data_types & INT_MASK))
            REPORT_ERROR(ERR_ARG_INCORRECT, "MaskProgram: binary masks are not allowed");

        R1 = program->getDoubleParam("--mask","crown",0);
        R2 = program->getDoubleParam("--mask","crown",1);

        if (R1 < 0 && R2 < 0)
        {
            Mask::mode = INNER_MASK;
            R1 = ABS(R1);
            R2 = ABS(R2);
        }
        else if (R1 > 0 && R2 > 0)
            Mask::mode = OUTSIDE_MASK;
        else
            REPORT_ERROR(ERR_ARG_INCORRECT, "MaskProgram: cannot determine mode for crown");

        type = BINARY_CROWN_MASK;
    }
    /*// Cylinder mask ........................................................*/
    else if (mask_type == "cylinder")
    {
        if (!(allowed_data_types & INT_MASK))
            REPORT_ERROR(ERR_ARG_INCORRECT, "MaskProgram: binary masks are not allowed");

        R1 = program->getDoubleParam("--mask","cylinder",0);
        H = program->getDoubleParam("--mask","cylinder",1);

        if (R1 < 0 && H < 0)
        {
            Mask::mode = INNER_MASK;
            R1 = ABS(R1);
            H = ABS(H);
        }
        else if (R1 > 0 && H > 0)
            Mask::mode = OUTSIDE_MASK;
        else
            REPORT_ERROR(ERR_ARG_INCORRECT, "MaskProgram: cannot determine mode for cylinder");

        type = BINARY_CYLINDER_MASK;
    }
    /*// Crown mask ...........................................................*/
    else if (mask_type == "tube")
    {
        if (!(allowed_data_types & INT_MASK))
            REPORT_ERROR(ERR_ARG_INCORRECT, "MaskProgram: binary masks are not allowed");

        R1 = program->getDoubleParam("--mask","tube",0);
        R2 = program->getDoubleParam("--mask","tube",1);
        H = program->getDoubleParam("--mask","tube",2);

        if (R1 < 0 && R2 < 0 && H<0)
        {
            Mask::mode = INNER_MASK;
            R1 = ABS(R1);
            R2 = ABS(R2);
            H=ABS(H);
        }
        else if (R1 > 0 && R2 > 0 && H>0)
            Mask::mode = OUTSIDE_MASK;
        else
            REPORT_ERROR(ERR_ARG_INCORRECT, "MaskProgram: cannot determine mode for tube");

        type = BINARY_TUBE;
    }
    /*// Gaussian mask ........................................................*/
    else if (mask_type == "gaussian")
    {
        if (!(allowed_data_types & DOUBLE_MASK))
            REPORT_ERROR(ERR_ARG_INCORRECT, "MaskProgram: continuous masks are not allowed");

        sigma = program->getDoubleParam("--mask","gaussian");

        if (sigma < 0)
        {
            Mask::mode = INNER_MASK;
            sigma = ABS(sigma);
        }
        else
            Mask::mode = OUTSIDE_MASK;

        type = GAUSSIAN_MASK;
    }
    /*// Raised cosine mask ...................................................*/
    else if (mask_type == "raised_cosine")
    {
        if (!(allowed_data_types & INT_MASK))
            REPORT_ERROR(ERR_ARG_INCORRECT, "MaskProgram: continuous masks are not allowed");

        R1 = program->getDoubleParam("--mask","raised_cosine",0);
        R2 = program->getDoubleParam("--mask","raised_cosine",1);

        if (R1 < 0 && R2 < 0)
        {
            Mask::mode = INNER_MASK;
            R1 = ABS(R1);
            R2 = ABS(R2);
        }
        else if (R1 > 0 && R2 > 0)
            Mask::mode = OUTSIDE_MASK;
        else
            REPORT_ERROR(ERR_ARG_INCORRECT, "MaskProgram: cannot determine mode for raised_cosine");

        type = RAISED_COSINE_MASK;
    }
    /*// Raised crown mask ....................................................*/
    else if (mask_type == "raised_crown")
    {
        if (!(allowed_data_types & INT_MASK))
            REPORT_ERROR(ERR_ARG_INCORRECT, "MaskProgram: continuous masks are not allowed");

        R1 = program->getDoubleParam("--mask","raised_crown",0);
        R2 = program->getDoubleParam("--mask","raised_crown",1);
        pix_width = program->getDoubleParam("--mask","raised_crown",2);

        if (R1 < 0 && R2 < 0)
        {
            Mask::mode = INNER_MASK;
            R1 = ABS(R1);
            R2 = ABS(R2);
        }
        else if (R1 > 0 && R2 > 0)
            Mask::mode = OUTSIDE_MASK;
        else
            REPORT_ERROR(ERR_ARG_INCORRECT, "MaskProgram: cannot determine mode for raised_cosine");

        type = RAISED_CROWN_MASK;
    }
    /*// Blob circular mask ....................................................*/
    else if (mask_type == "blob_circular")
    {
        if (!(allowed_data_types & INT_MASK))
            REPORT_ERROR(ERR_ARG_INCORRECT, "MaskProgram: continuous masks are not allowed");

        R1 = program->getDoubleParam("--mask","blob_circular",0);
        double aux = program->getDoubleParam("--mask","blob_circular",1);
        blob_radius= ABS(aux);

        if (aux < 0)
            Mask::mode = INNER_MASK;
        else if (aux > 0)
            Mask::mode = OUTSIDE_MASK;
        else
            REPORT_ERROR(ERR_ARG_INCORRECT, "MaskProgram: cannot determine mode for blob_circular");

        type = BLOB_CIRCULAR_MASK;
        blob_order= program->getIntParam("-m");
        blob_alpha= program->getIntParam("-a");
    }
    /*// Raised crown mask ....................................................*/
    else if (mask_type == "blob_crown")
    {
        if (!(allowed_data_types & INT_MASK))
            REPORT_ERROR(ERR_ARG_INCORRECT, "MaskProgram: continuous masks are not allowed");

        R1 = program->getDoubleParam("--mask","blob_crown",0);
        R2 = program->getDoubleParam("--mask","blob_crown",1);
        double aux = program->getDoubleParam("--mask","blob_crown",2);
        blob_radius= ABS(aux);

        if (aux < 0)
            Mask::mode = INNER_MASK;
        else if (aux > 0)
            Mask::mode = OUTSIDE_MASK;
        else
            REPORT_ERROR(ERR_ARG_INCORRECT, "MaskProgram: cannot determine mode for blob_crown");

        type = BLOB_CROWN_MASK;
        blob_order= program->getIntParam("-m");
        blob_alpha= program->getDoubleParam("-a");
    }
    /*// Blackman mask ........................................................*/
    else if (mask_type == "blackman")
    {
        Mask::mode = INNER_MASK;
        type = BLACKMAN_MASK;
    }
    /*// Sinc mask ............................................................*/
    else if (mask_type == "sinc")
    {
        if (!(allowed_data_types & INT_MASK))
            REPORT_ERROR(ERR_ARG_INCORRECT, "MaskProgram: binary masks are not allowed");

        omega = program->getDoubleParam("--mask","sinc");

        if (omega < 0)
        {
            Mask::mode = INNER_MASK;
            omega = ABS(omega);
        }
        else
            Mask::mode = OUTSIDE_MASK;

        type = SINC_MASK;
    }
    else if (mask_type == "binary_file")
    {
        fn_mask = program->getParam("--mask","binary_file");
        type = READ_BINARY_MASK;
    }
    else if (mask_type == "real_file")
    {
        fn_mask = program->getParam("--mask","real_file");
        type = READ_REAL_MASK;
    }
    else
        REPORT_ERROR(ERR_DEBUG_IMPOSIBLE,"You should never see  this meessage, Mask::readParams ");
}

resize() [1/4]

void Mask::resize

(

size_t

Xdim

)

Resize and set Xmipp origin

Definition at line 654 of file mask.cpp.

{
    switch (datatype())
    {
    case INT_MASK:
        imask.resize(Xdim);
        imask.setXmippOrigin();
        break;
    case DOUBLE_MASK:
        dmask.resize(Xdim);
        dmask.setXmippOrigin();
        break;
    }
}

resize() [2/4]

void Mask::resize	(	size_t	Ydim,
		size_t	Xdim
	)

Resize and set Xmipp origin

Definition at line 669 of file mask.cpp.

{
    switch (datatype())
    {
    case INT_MASK:
        imask.resize(Ydim, Xdim);
        imask.setXmippOrigin();
        break;
    case DOUBLE_MASK:
        dmask.resize(Ydim, Xdim);
        dmask.setXmippOrigin();
        break;
    }
}

resize() [3/4]

void Mask::resize	(	size_t	Zdim,
		size_t	Ydim,
		size_t	Xdim
	)

Resize and set Xmipp origin

Definition at line 684 of file mask.cpp.

{
    switch (datatype())
    {
    case INT_MASK:
        imask.resize(Zdim, Ydim, Xdim);
        imask.setXmippOrigin();
        break;
    case DOUBLE_MASK:
        dmask.resize(Zdim, Ydim, Xdim);
        dmask.setXmippOrigin();
        break;
    }
}

resize() [4/4]

template<typename T >

void Mask::resize ( const MultidimArray< T > &  m )

inline

Resize after a pattern

Definition at line 578 of file mask.h.

    {
        switch (datatype())
        {
        case INT_MASK:
            imask.resizeNoCopy(m);
            break;

        case DOUBLE_MASK:
            dmask.resizeNoCopy(m);
            break;
        }
    }

set_binary_mask()

void Mask::set_binary_mask ( MultidimArray< int > &  _imask )

inline

Set binary mask

Definition at line 721 of file mask.h.

    {
        imask = _imask;
    }

set_cont_mask()

void Mask::set_cont_mask ( MultidimArray< double > &  _dmask )

inline

Set continuous mask

Definition at line 742 of file mask.h.

    {
        dmask = _dmask;
    }

show()

void Mask::show

(

)

const

Read parametersShow

Definition at line 1021 of file mask.cpp.

{
#define SHOW_MODE \
    if (mode==INNER_MASK) std::cout << "   mode=INNER MASK\n"; \
    else                  std::cout << "   mode=OUTER MASK\n";
#define SHOW_CENTER \
    std::cout << "   (x0,y0,z0)=(" << x0 << "," << y0 << "," << z0 << ")\n";
    switch (type)
    {
    case NO_MASK:
        std::cout << "Mask type: No mask\n";
        break;
    case BINARY_CIRCULAR_MASK:
        std::cout << "Mask type: Binary circular\n"
        << "   R=" << R1 << std::endl;
        SHOW_MODE;
        SHOW_CENTER;
        break;
    case BINARY_DWT_CIRCULAR_MASK:
        std::cout << "Mask type: Binary DWT circular\n"
        << "   R=" << R1 << std::endl
        << "   smin=" << smin << std::endl
        << "   smax=" << smax << std::endl
        << "   quadrant=" << quadrant << std::endl;
        break;
    case BINARY_CROWN_MASK:
        std::cout << "Mask type: Binary crown\n"
        << "   R1=" << R1 << std::endl
        << "   R2=" << R2 << std::endl;
        SHOW_MODE;
        SHOW_CENTER;
        break;
    case BINARY_CYLINDER_MASK:
        std::cout << "Mask type: Cylinder\n"
        << "   R1=" << R1 << std::endl
        << "   H=" << H << std::endl;
        SHOW_MODE;
        SHOW_CENTER;
        break;
    case BINARY_TUBE:
        std::cout << "Mask type: Tube\n"
        << "   R1=" << R1 << std::endl
        << "   R2=" << R2 << std::endl
        << "   H=" << H << std::endl;
        SHOW_MODE;
        SHOW_CENTER;
        break;
    case BINARY_FRAME_MASK:
        std::cout << "Mask type: Frame\n"
        << "   Xrect=" << Xrect << std::endl
        << "   Yrect=" << Yrect << std::endl;
        SHOW_MODE;
        SHOW_CENTER;
        break;
    case GAUSSIAN_MASK:
        std::cout << "Mask type: Gaussian\n"
        << "   sigma=" << sigma << std::endl;
        SHOW_MODE;
        SHOW_CENTER;
        break;
    case RAISED_COSINE_MASK:
        std::cout << "Mask type: Raised cosine\n"
        << "   R1=" << R1 << std::endl
        << "   R2=" << R2 << std::endl;
        SHOW_MODE;
        SHOW_CENTER;
        break;
    case RAISED_CROWN_MASK:
        std::cout << "Mask type: Raised crown\n"
        << "   R1=" << R1 << std::endl
        << "   R2=" << R2 << std::endl
        << "   pixwidth=" << pix_width << std::endl;
        SHOW_MODE;
        SHOW_CENTER;
        break;
    case BLOB_CIRCULAR_MASK:
        std::cout << "Mask type: Blob circular\n"
        << "   R1=" << R1 << std::endl
        << "   blob radius=" << blob_radius << std::endl
        << "   blob order="  << blob_order  << std::endl
        << "   blob alpha="  << blob_alpha  << std::endl;
        SHOW_MODE;
        SHOW_CENTER;
        break;
    case BLOB_CROWN_MASK:
        std::cout << "Mask type: Blob crown\n"
        << "   R1=" << R1 << std::endl
        << "   R2=" << R2 << std::endl
        << "   blob radius=" << blob_radius << std::endl
        << "   blob order="  << blob_order  << std::endl
        << "   blob alpha="  << blob_alpha  << std::endl;
        SHOW_MODE;
        SHOW_CENTER;
        break;
    case BLACKMAN_MASK:
        std::cout << "Mask type: Blackman\n";
        SHOW_MODE;
        SHOW_CENTER;
        break;
    case SINC_MASK:
        std::cout << "Mask type: Sinc\n"
        << "   w=" << omega << std::endl;
        SHOW_MODE;
        SHOW_CENTER;
        break;
    default:
        std::cout << "Mask type: Read from disk\n"
        << "   File=" << fn_mask << std::endl;
        break;
    }
}

usage()

void Mask::usage

(

)

const

Usage

Definition at line 1134 of file mask.cpp.

{
    std::cerr << "Mask usage:\n";
    std::cerr << "   [-center <x0=0> <y0=0> <z0=0>]: Center of the mask\n";
    if (allowed_data_types & INT_MASK)
        std::cerr << "   [-mask circular <R>       : circle/sphere mask\n"
        << "                               if R>0 => outside R\n"
        << "                               if R<0 => inside  R\n"
        << "   [-mask DWT_circular <R> <smin> <smax>: circle/sphere mask\n"
        << "                               smin and smax define the scales\n"
        << "                               to be kept\n"
        << "   |-mask rectangular <Xrect> <Yrect> [<Zrect>]: 2D or 3D rectangle\n"
        << "                               if X,Y,Z > 0 => outside rectangle\n"
        << "                               if X,Y,Z < 0 => inside rectangle\n"
        << "   |-mask crown <R1> <R2>    : 2D or 3D crown\n"
        << "                               if R1,R2 > 0 => outside crown\n"
        << "                               if R1,R2 < 0 => inside crown\n"
        << "   |-mask cylinder <R> <H>   : 2D circle or 3D cylinder\n"
        << "                               if R,H > 0 => outside cylinder\n"
        << "                               if R,H < 0 => inside cylinder\n"
        << "   |-mask tube <R1> <R2> <H> : 2D or 3D tube\n"
        << "                               if R1,R2,H > 0 => outside tube\n"
        << "                               if R1,R2,H < 0 => inside tube\n"
        << "   |-mask cone <theta>       : 3D cone (parallel to Z) \n"
        << "                               if theta > 0 => outside cone\n"
        << "                               if theta < 0 => inside cone\n"
        << "   |-mask wedge <th0> <thF>  : 3D missing-wedge mask for data \n"
        << "                               collected between tilting angles \n"
        << "                               th0 and thF (around the Y-axis) \n"
        << "   |-mask <binary file>      : Read from file\n"
        ;
    if (allowed_data_types & DOUBLE_MASK)
        std::cerr << "   |-mask gaussian <sigma>   : 2D or 3D gaussian\n"
        << "                               if sigma > 0 => outside gaussian\n"
        << "                               if sigma < 0 => inside gaussian\n"
        << "   |-mask raised_cosine <R1> <R2>: 2D or 3D raised_cosine\n"
        << "                               if R1,R2 > 0 => outside sphere\n"
        << "                               if R1,R2 < 0 => inside sphere\n"
        << "   |-mask raised_crown <R1> <R2> <pixwidth>: 2D or 3D raised_crown\n"
        << "                               if R1,R2 > 0 => outside crown\n"
        << "                               if R1,R2 < 0 => inside crown\n"
        << "   |-mask blob_circular <R1> <blob_radius>: 2D or 3D blob circular\n"
        << "                               if blob_radius > 0 => outside blob\n"
        << "                               if blob_radius < 0 => inside blob\n"
        << "   |-mask blob_crown <R1> <R2> <blob_radius>: 2D or 3D blob_crown\n"
        << "                               if blob_radius > 0 => outside crown\n"
        << "                               if blob_radius < 0 => inside crown\n"
        << "   [ -m <blob_order=2>       : Order of blob\n"
        << "   [ -a <blob_alpha=10.4>    : Alpha of blob\n"
        << "   |-mask blackman           : 2D or 3D Blackman mask\n"
        << "                               always inside blackman\n"
        << "   |-mask sinc <w>]          : 2D or 3D sincs\n"
        << "                               if w > 0 => outside sinc\n"
        << "                               if w < 0 => inside sinc\n"
        ;
}

write_mask()

void Mask::write_mask

(

const FileName &

fn

)

Save mask as an image

Definition at line 1192 of file mask.cpp.

{
    Image<double> img;
    if (datatype() == INT_MASK)
        typeCast(imask, img());
    else if (datatype() == DOUBLE_MASK)
        img()=dmask;
    img.write(fn);
}

Member Data Documentation

allowed_data_types

int Mask::allowed_data_types

Allowed data types.

Definition at line 495 of file mask.h.

blob_alpha

double Mask::blob_alpha

Definition at line 432 of file mask.h.

blob_order

int Mask::blob_order

Blob parameters For blob_circular and blob_crown masks.

Definition at line 428 of file mask.h.

blob_radius

double Mask::blob_radius

Blob parameters

Definition at line 431 of file mask.h.

dmask

MultidimArray< double > Mask::dmask

double mask

Definition at line 503 of file mask.h.

fn_mask

FileName Mask::fn_mask

Filename from which the mask is read, if it is the case

Definition at line 487 of file mask.h.

H

double Mask::H

Height Height for cylinders.

Definition at line 437 of file mask.h.

imask

MultidimArray< int > Mask::imask

integer mask

Definition at line 499 of file mask.h.

mask_geo

Matrix2D< double > Mask::mask_geo

Geometrix transformation matrix for the mask

Definition at line 491 of file mask.h.

mask_type

std::string Mask::mask_type

Mask type

Definition at line 507 of file mask.h.

mode

int Mask::mode

Mode The valid modes are INNER_MASK and OUTSIDE_MASK.

Definition at line 407 of file mask.h.

omega

double Mask::omega

Omega Frequency for sincs

Definition at line 447 of file mask.h.

pix_width

double Mask::pix_width

Pixel width For raised crowns.

Definition at line 423 of file mask.h.

quadrant

std::string Mask::quadrant

Quadrant If it is empty then all, except 000, are generated.

Definition at line 483 of file mask.h.

R1

double Mask::R1

Radius 1 Radius for Circular and Cylinder masks and R1 for crowns and raised cosine.

Definition at line 413 of file mask.h.

R2

double Mask::R2

Radius 2 R2 for crowns and raised cosine.

Definition at line 418 of file mask.h.

sigma

double Mask::sigma

Sigma Sigma for gaussians.

Definition at line 442 of file mask.h.

smax

int Mask::smax

Maximum scale for DWT masks

Definition at line 478 of file mask.h.

smin

int Mask::smin

Minimum scale for DWT masks

Definition at line 474 of file mask.h.

type

int Mask::type

Mask Type

The only valid types are BINARY_CIRCULAR_MASK, BINARY_CROWN_MASK, BINARY_CYLINDER_MASK, BINARY_FRAME_MASK, GAUSSIAN_MASK, RAISED_COSINE_MASK, BLACKMAN_MASK, SINC_MASK, SINC_BLACKMAN_MASK, READ_MASK, RAISED_CROWN_MASK, BINARY_CONE_MASK, BINARY_WEDGE_MASK, BLOB_CIRCULAR_MASK, BLOB_CROWN_MASK, BINARY_TUBE

Definition at line 402 of file mask.h.

x0

double Mask::x0

X origin

Definition at line 470 of file mask.h.

Xrect

int Mask::Xrect

Rectangular X dimension

Definition at line 451 of file mask.h.

y0

double Mask::y0

Y origin

Definition at line 466 of file mask.h.

Yrect

int Mask::Yrect

Rectangular Y dimension

Definition at line 455 of file mask.h.

z0

double Mask::z0

Z origin

Definition at line 462 of file mask.h.

Zrect

int Mask::Zrect

Rectangular Z dimension

Definition at line 459 of file mask.h.

---

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

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