Masks

Collaboration diagram for Masks:

Classes
class	Mask
class	ProgMask

Functions
void	apply_geo_binary_2D_mask (MultidimArray< int > &mask, const Matrix2D< double > &A)
void	apply_geo_cont_2D_mask (MultidimArray< double > &mask, const Matrix2D< double > &A)

Variables
constexpr int	INNER_MASK = 1
constexpr int	OUTSIDE_MASK = 2
constexpr int	NO_ACTIVATE = 0
constexpr int	ACTIVATE = 1

Actual masks
void	RaisedCosineMask (MultidimArray< double > &mask, double r1, double r2, int mode=INNER_MASK, double x0=0, double y0=0, double z0=0)
void	RaisedCrownMask (MultidimArray< double > &mask, double r1, double r2, double pix_width, int mode=INNER_MASK, double x0=0, double y0=0, double z0=0)
void	KaiserMask (MultidimArray< double > &mask, double delta=0.01, double Deltaw=1.0/12.0)
void	SincMask (MultidimArray< double > &mask, double omega, int mode=INNER_MASK, double x0=0, double y0=0, double z0=0)
void	SincKaiserMask (MultidimArray< double > &mask, double omega, double delta=0.01, double Deltaw=1.0/12.0)
void	BlackmanMask (MultidimArray< double > &mask, int mode=INNER_MASK, double x0=0, double y0=0, double z0=0)
void	SincBlackmanMask (MultidimArray< double > &mask, double omega, double power_percentage, double x0=0, double y0=0, double z0=0)
void	BinaryCircularMask (MultidimArray< int > &mask, double radius, int mode=INNER_MASK, double x0=0, double y0=0, double z0=0)
void	BlobCircularMask (MultidimArray< double > &mask, double r1, blobtype blob, int mode, double x0=0, double y0=0, double z0=0)
void	BinaryCrownMask (MultidimArray< int > &mask, double R1, double R2, int mode=INNER_MASK, double x0=0, double y0=0, double z0=0)
void	BlobCrownMask (MultidimArray< double > &mask, double r1, double r2, blobtype blob, int mode, double x0=0, double y0=0, double z0=0)
void	GaussianMask (MultidimArray< double > &mask, double sigma, int mode=INNER_MASK, double x0=0, double y0=0, double z0=0)
void	BinaryDWTCircularMask2D (MultidimArray< int > &mask, double radius, int smin, int smax, const std::string &quadrant)
void	SeparableSincKaiserMask2D (MultidimArray< double > &mask, double omega, double delta=0.01, double Deltaw=1.0/12.0)
void	mask2D_4neig (MultidimArray< int > &mask, int value=1, int center=NO_ACTIVATE)
void	mask2D_8neig (MultidimArray< int > &mask, int value1=1, int value2=1, int center=NO_ACTIVATE)
void	BinaryDWTSphericalMask2D (MultidimArray< int > &mask, double radius, int smin, int smax, const std::string &quadrant)
void	BinaryCylinderMask (MultidimArray< int > &mask, double R, double H, int mode=INNER_MASK, double x0=0, double y0=0, int z0=0)
void	BinaryFrameMask (MultidimArray< int > &mask, int Xrect, int Yrect, int Zrect, int mode=INNER_MASK, double x0=0, double y0=0, double z0=0)
void	BinaryConeMask (MultidimArray< int > &mask, double theta, int mode=INNER_MASK, bool centerOrigin=false)
void	BinaryWedgeMask (MultidimArray< int > &mask, double theta0, double thetaF, const Matrix2D< double > &A, bool centerOrigin=false)
void	mask3D_6neig (MultidimArray< int > &mask, int value=1, int center=NO_ACTIVATE)
void	mask3D_18neig (MultidimArray< int > &mask, int value1=1, int value2=1, int center=NO_ACTIVATE)
void	mask3D_26neig (MultidimArray< int > &mask, int value1=1, int value2=1, int value3=1, int center=NO_ACTIVATE)

Mask Tools
All Mask tools work only in the overlapping area of the given image/volume and the mask in logical coordinates. Ie, if you have a mask defined from -2 to 2 and you apply it to an image defined from 0 to 63 then only those values of the mask between 0 and 2 will be applied. The rest of the image will remain untouched. This region where the mask is active within the overlapping area will be called in this documentation: active area.
constexpr int	COUNT_ABOVE = 1
constexpr int	COUNT_BELOW = 2
constexpr int	COUNT_BETWEEN = 3
template<typename T1 , typename T >
void	computeStats_within_binary_mask (const MultidimArray< T1 > &mask, const MultidimArray< T > &m, double &min_val, double &max_val, double &avg, double &stddev)
void	computeStats_within_binary_mask (const MultidimArray< int > &mask, const MultidimArrayGeneric &m, double &min_val, double &max_val, double &avg, double &stddev)
template<typename T >
void	apply_binary_mask (const MultidimArray< int > &mask, const MultidimArray< T > &m_in, MultidimArray< T > &m_out, T subs_val=(T) 0)
template<typename T >
void	apply_cont_mask (const MultidimArray< double > &mask, const MultidimArray< T > &m_in, MultidimArray< T > &m_out)
template<typename T >
void	compute_hist_within_binary_mask (const MultidimArray< int > &mask, MultidimArray< T > &v, Histogram1D &hist, int no_steps)
template<typename T >
void	compute_hist_within_binary_mask (const MultidimArray< int > &mask, const MultidimArray< T > &v, Histogram1D &hist, T min, T max, int no_steps)
template<typename T >
int	count_with_mask (const MultidimArray< int > &mask, const MultidimArray< T > &m, int mode, double th1, double th2)
int	count_with_mask (const MultidimArray< int > &mask, const MultidimArray< std::complex< double > > &m, int mode, double th1, double th2)
template<typename T >
void	invert_binary_mask (MultidimArray< T > &mask)
void	rangeAdjust_within_mask (const MultidimArray< double > *mask, const MultidimArray< double > &m1, MultidimArray< double > &m2)
#define	count_with_mask_above(mask, m, th)   count_with_mask(mask, m, COUNT_ABOVE, th, 0);
#define	count_with_mask_below(mask, m, th)   count_with_mask(mask, m, COUNT_BELOW, th, 0);
#define	count_with_mask_between(mask, m, th1, th2)   count_with_mask(mask, m, COUNT_BETWEEN, th1, th2);

Detailed Description

Macro Definition Documentation

count_with_mask_above

#define count_with_mask_above	(		mask,
			m,
			th
	)		count_with_mask(mask, m, COUNT_ABOVE, th, 0);

Count pixels/voxels with mask and above a threshold

Those pixels within the mask with a value greater or equal than a threshold are counted. This function makes a call to count_with_mask

Definition at line 951 of file mask.h.

count_with_mask_below

#define count_with_mask_below	(		mask,
			m,
			th
	)		count_with_mask(mask, m, COUNT_BELOW, th, 0);

Count pixels/voxels with mask and below a threshold

Those pixels within the mask with a value smaller or equal than a threshold are counted. This function makes a call to count_with_mask

Definition at line 959 of file mask.h.

count_with_mask_between

#define count_with_mask_between	(		mask,
			m,
			th1,
			th2
	)		count_with_mask(mask, m, COUNT_BETWEEN, th1, th2);

Count pixels/voxels with mask and between two thresholds

Those pixels within the mask with a value greater or equal than th1 and smaller or equal than th2 are counted. This function makes a call to count_with_mask

Definition at line 968 of file mask.h.

Function Documentation

apply_binary_mask()

template<typename T >

void apply_binary_mask	(	const MultidimArray< int > &	mask,
		const MultidimArray< T > &	m_in,
		MultidimArray< T > &	m_out,
		T	subs_val = (T) 0
	)

Apply mask to a MultidimArray

The volume values for which the input mask is 0 are set to 0. The input and output volumes can be the same ones.

Definition at line 857 of file mask.h.

{
    m_out.resize(m_in);
    FOR_ALL_ELEMENTS_IN_ARRAY3D(m_out)
    // If in common with the mask
    if (k >= STARTINGZ(mask) && k <= FINISHINGZ(mask) &&
        i >= STARTINGY(mask) && i <= FINISHINGY(mask) &&
        j >= STARTINGX(mask) && j <= FINISHINGX(mask))
        if (A3D_ELEM(mask, k, i, j) == 0)
            A3D_ELEM(m_out, k, i, j) = subs_val;
        else
            A3D_ELEM(m_out, k, i, j) = A3D_ELEM(m_in, k, i, j);
    // It is not in common, leave the original one
    else
        A3D_ELEM(m_out, k, i, j) = A3D_ELEM(m_in, k, i, j);
}

apply_cont_mask()

template<typename T >

void apply_cont_mask	(	const MultidimArray< double > &	mask,
		const MultidimArray< T > &	m_in,
		MultidimArray< T > &	m_out
	)

Apply continuous mask to a MultidimArray

The image is multiplied by the mask. The input and output matrices can be the same ones. Only the overlapping values are affected by the mask.

Definition at line 881 of file mask.h.

{
    m_out.resize(m_in);
    FOR_ALL_ELEMENTS_IN_ARRAY3D(m_out)
    // If in common with the mask
    if ((k >= STARTINGZ(mask)) && (k <= FINISHINGZ(mask)) &&
        (i >= STARTINGY(mask)) && (i <= FINISHINGY(mask)) &&
        (j >= STARTINGX(mask) && j <= FINISHINGX(mask)))
    {
        A3D_ELEM(m_out, k, i, j) = (T)(A3D_ELEM(m_in, k, i, j) * A3D_ELEM(mask, k, i, j));
    }
    // It is not in common, leave the original one
    else
        A3D_ELEM(m_out, k, i, j) = A3D_ELEM(m_in, k, i, j);
}

apply_geo_binary_2D_mask()

void apply_geo_binary_2D_mask	(	MultidimArray< int > &	mask,
		const Matrix2D< double > &	A
	)

Apply geometric transformation to a binary (2D) mask

Definition at line 1682 of file mask.cpp.

{
    MultidimArray<double> tmp;
    tmp.resize(mask);
    typeCast(mask, tmp);
    double outside = DIRECT_A2D_ELEM(tmp, 0, 0);
    MultidimArray<double> tmp2;
    tmp2 = tmp;
    // Instead of IS_INV for images use IS_NOT_INV for masks!
    applyGeometry(xmipp_transformation::LINEAR, tmp, tmp2, A, xmipp_transformation::IS_NOT_INV, xmipp_transformation::DONT_WRAP, outside);
    // The type cast gives strange results here, using round instead
    //typeCast(tmp, mask);
    FOR_ALL_DIRECT_ELEMENTS_IN_ARRAY2D(mask)
    {
        dAij(mask,i,j)=ROUND(dAij(tmp,i,j));
        //        std::cout << "i, j = " << i << "," << j <<std::endl;
    }
}

apply_geo_cont_2D_mask()

void apply_geo_cont_2D_mask	(	MultidimArray< double > &	mask,
		const Matrix2D< double > &	A
	)

Apply geometric transformation to a continuous (2D) mask

Definition at line 1703 of file mask.cpp.

{
    double outside = DIRECT_A2D_ELEM(mask, 0, 0);
    MultidimArray<double> tmp = mask;
    // Instead of IS_INV for images use IS_NOT_INV for masks!
    applyGeometry(xmipp_transformation::LINEAR, tmp, mask, A, xmipp_transformation::IS_NOT_INV, xmipp_transformation::DONT_WRAP, outside);
}

BinaryCircularMask()

void BinaryCircularMask	(	MultidimArray< int > &	mask,
		double	radius,
		int	mode = INNER_MASK,
		double	x0 = 0,
		double	y0 = 0,
		double	z0 = 0
	)

Creates a circular mask for already sized masks

The mask is supposed to be resized and with its logical origin already set. A circle placed logically at (x0,y0,z0), by default (0,0,0), is created with the radius indicated. The only two valid modes are INNER_MASK (by default) or OUTSIDE_MASK. When entering the mask is initialiazed to 0 and then the mask is created.

Definition at line 193 of file mask.cpp.

{
    mask.initZeros();
    double radius2 = radius * radius;
    for (int k=STARTINGZ(mask); k<=FINISHINGZ(mask); ++k)
    {
        double diff=k - z0;
        double z2=diff*diff;
        for (int i=STARTINGY(mask); i<=FINISHINGY(mask); ++i)
        {
            diff=i - y0;
            double z2y2=z2+diff*diff;
            for (int j=STARTINGX(mask); j<=FINISHINGX(mask); ++j)
            {
                diff=j - x0;
                double r2 = z2y2+diff*diff;
                if (r2 <= radius2 && mode == INNER_MASK)
                    A3D_ELEM(mask, k, i, j) = 1;
                else if (r2 >= radius2 && mode == OUTSIDE_MASK)
                    A3D_ELEM(mask, k, i, j) = 1;
            }
        }
    }
}

BinaryConeMask()

void BinaryConeMask	(	MultidimArray< int > &	mask,
		double	theta,
		int	mode = INNER_MASK,
		bool	centerOrigin = false
	)

Creates a 3D cone mask for already sized masks

The mask is supposed to be resized and with its logical origin already set. A cone with angle theta is placed parallel to the Z-axis and centered at (x0,y0,z0). The only two valid modes are INNER_MASK (by default, inside the crown is zero, outside is 1) or OUTSIDE_MASK (the negative of the crown).

When entering the mask is initialiazed to 0 and then the mask is created.

Definition at line 488 of file mask.cpp.

{
    int halfX = mask.xdim/2;
    int halfY = mask.ydim/2;
    int halfZ = mask.zdim/2;

    int minX = -halfX;
    int minY = -halfY;
    int minZ = -halfZ;

    int maxX = (int)((mask.xdim-0.5)/2);
    int maxY = (int)((mask.ydim-0.5)/2);
    int maxZ = (int)((mask.zdim-0.5)/2);

    FOR_ALL_ELEMENTS_IN_ARRAY3D(mask)
    {
        int kpp = k;
        int ipp = i;
        int jpp = j;
        if (centerOrigin)
        {
            kpp = intWRAP (k+halfZ,minZ,maxZ);
            ipp = intWRAP (i+halfY,minY,maxY);
            jpp = intWRAP (j+halfX,minX,maxX);
        }

        double rad = tan(PI * theta / 180.) * (double)k;
        if ((double)(i*i + j*j) < (rad*rad))
            A3D_ELEM(mask, kpp, ipp, jpp) = 0;
        else
            A3D_ELEM(mask, kpp, ipp, jpp) = 1;
        if (mode == OUTSIDE_MASK)
            A3D_ELEM(mask, kpp, ipp, jpp) = 1 - A3D_ELEM(mask, kpp, ipp, jpp);
    }
}

BinaryCrownMask()

void BinaryCrownMask	(	MultidimArray< int > &	mask,
		double	R1,
		double	R2,
		int	mode = INNER_MASK,
		double	x0 = 0,
		double	y0 = 0,
		double	z0 = 0
	)

Creates a crown mask for already sized masks

The mask is supposed to be resized and with its logical origin already set. A circle placed logically at (x0,y0,z0), by default (0,0,0), is created with the two radii indicated. The only two valid modes are INNER_MASK (by default, between the two radii) or OUTSIDE_MASK (the negative of the crown). It is supposed that R1 is smaller than R2.

When entering the mask is initialiazed to 0 and then the mask is created.

Definition at line 244 of file mask.cpp.

{
    mask.initZeros();
    double R12 = R1 * R1;
    double R22 = R2 * R2;
    FOR_ALL_ELEMENTS_IN_ARRAY3D(mask)
    {
        double r2 = (k - z0) * (k - z0) + (i - y0) * (i - y0) + (j - x0) * (j - x0);
        bool in_crown = (r2 >= R12 && r2 <= R22);
        if (in_crown  && mode == INNER_MASK)
            A3D_ELEM(mask, k, i, j) = 1;
        else if (!in_crown && mode == OUTSIDE_MASK)
            A3D_ELEM(mask, k, i, j) = 1;
    }
}

BinaryCylinderMask()

void BinaryCylinderMask	(	MultidimArray< int > &	mask,
		double	R,
		double	H,
		int	mode = INNER_MASK,
		double	x0 = 0,
		double	y0 = 0,
		int	z0 = 0
	)

Creates a 3D Cylinder mask for already sized masks

The mask is supposed to be already resized and with its logical origin defined. A cylinder placed logically at (z0,x0,y0), by default (0,0,0), is created with the radius and height indicated. The only two valid modes ar INNER_MASK (by default) or OUTSIDE_MASK. When entering the mask is initialiazed to 0 and then the mask is created.

BinaryDWTCircularMask2D()

void BinaryDWTCircularMask2D	(	MultidimArray< int > &	mask,
		double	radius,
		int	smin,
		int	smax,
		const std::string &	quadrant
	)

Binary Circular 2D mask in wavelet space

Definition at line 356 of file mask.cpp.

{
    double radius2 = radius * radius / (4 * (smin + 1));
    mask.initZeros();
    for (int s = smin; s <= smax; s++)
    {
        Matrix1D<int> corner1(2);
        Matrix1D<int> corner2(2);
        Matrix1D<int> r(2);
        Matrix1D<double> center(2);
        if (quadrant == "xx")
        {
            DWTCIRCULAR2D_BLOCK(s, "01");
            DWTCIRCULAR2D_BLOCK(s, "10");
            DWTCIRCULAR2D_BLOCK(s, "11");
        }
        else
            DWTCIRCULAR2D_BLOCK(s, quadrant);
        radius2 /= 4;
    }
}

BinaryDWTSphericalMask2D()

void BinaryDWTSphericalMask2D	(	MultidimArray< int > &	mask,
		double	radius,
		int	smin,
		int	smax,
		const std::string &	quadrant
	)

Creates a 3D DWT spherical for already sized masks

The mask size must be a power of 2. The radius must be expressed in pixel units corresponding to the size of the image. For instance, a 64x64x64 image might have a radius of 32 pixels to concentrate on the central part only.

If quadrant=xxx then 001,010,011,100,101,110 and 111 are generated together

BinaryFrameMask()

void BinaryFrameMask	(	MultidimArray< int > &	mask,
		int	Xrect,
		int	Yrect,
		int	Zrect,
		int	mode = INNER_MASK,
		double	x0 = 0,
		double	y0 = 0,
		double	z0 = 0
	)

Creates a 3D frame mask for already sized masks

The mask is supposed to be resized and with its logical origin already set. A square placed logically at (x0,y0,z0), by default (0,0,0), is created with the two rectangular dimensions indicated. The only two valid modes are INNER_MASK (by default, between the two radii) or OUTSIDE_MASK (the negative of the crown). It is supposed that R1 is smaller than R2.

When entering the mask is initialiazed to 0 and then the mask is created.

Definition at line 309 of file mask.cpp.

{
    mask.initZeros();
    FOR_ALL_ELEMENTS_IN_ARRAY3D(mask)
    {
        bool in_frame =
            (j >= x0 + FIRST_XMIPP_INDEX(Xrect)) && (j <= x0 + LAST_XMIPP_INDEX(Xrect)) &&
            (i >= y0 + FIRST_XMIPP_INDEX(Yrect)) && (i <= y0 + LAST_XMIPP_INDEX(Yrect)) &&
            (k >= z0 + FIRST_XMIPP_INDEX(Zrect)) && (k <= z0 + LAST_XMIPP_INDEX(Zrect));

        if ((in_frame  && mode == INNER_MASK) || (!in_frame && mode == OUTSIDE_MASK))
            A3D_ELEM(mask, k, i, j) = 1;
    }
}

BinaryWedgeMask()

void BinaryWedgeMask	(	MultidimArray< int > &	mask,
		double	theta0,
		double	thetaF,
		const Matrix2D< double > &	A,
		bool	centerOrigin = false
	)

Creates a 3D missing wedge mask

The mask is supposed to be resized and with its logical origin already set. theta0 and thetaF are the tilting angles (around the Y-axis) wherin between the data is supposed to be collected. In this region the mask will be one, outside (ie in the missing wedge) it will be zero. The mask is centered at (x0,y0,z0), and rotated with respect to euler angle matrix A.

Definition at line 524 of file mask.cpp.

{
    int halfX = mask.xdim/2;
    int halfY = mask.ydim/2;
    int halfZ = mask.zdim/2;

    int minX = -halfX;
    int minY = -halfY;
    int minZ = -halfZ;

    int maxX = (int)((mask.xdim-0.5)/2);
    int maxY = (int)((mask.ydim-0.5)/2);
    int maxZ = (int)((mask.zdim-0.5)/2);

    auto tg0 = -tan(PI * (-90. - thetaF) / 180.);
    auto tgF = -tan(PI * (90. - theta0) / 180.);
    if (ABS(tg0) < XMIPP_EQUAL_ACCURACY)
        tg0=0.;
    if (ABS(tgF) < XMIPP_EQUAL_ACCURACY)
        tgF=0.;
    // ROB: A=A.inv(); A no const
    FOR_ALL_ELEMENTS_IN_ARRAY3D(mask)
    {
        auto di=(double)i;
        auto dj=(double)j;
        auto dk=(double)k;
        auto xp = MAT_ELEM(A, 0, 0) * dj + MAT_ELEM(A, 0, 1) * di + MAT_ELEM(A, 0, 2) * dk;
        auto zp = MAT_ELEM(A, 2, 0) * dj + MAT_ELEM(A, 2, 1) * di + MAT_ELEM(A, 2, 2) * dk;

        int kpp = k;
        int ipp = i;
        int jpp = j;

        if (centerOrigin)
        {
            kpp = intWRAP (k+halfZ,minZ,maxZ);
            ipp = intWRAP (i+halfY,minY,maxY);
            jpp = intWRAP (j+halfX,minX,maxX);
        }

        auto limx0 = tg0 * zp;// + 0.5;
        auto limxF = tgF * zp;// + 0.5;
        if (zp >= 0)
        {
            if (xp <= limx0 || xp >= limxF)
            {
                A3D_ELEM(mask, kpp, ipp, jpp) = 1;
            }
            else
                A3D_ELEM(mask, kpp, ipp, jpp) = 0;
        }
        else
        {
            if (xp <= limxF || xp >= limx0)
            {
                A3D_ELEM(mask, kpp, ipp, jpp) = 1;
            }
            else
                A3D_ELEM(mask, kpp, ipp, jpp) = 0;
        }
    }
}

BlackmanMask()

void BlackmanMask	(	MultidimArray< double > &	mask,
		int	mode = INNER_MASK,
		double	x0 = 0,
		double	y0 = 0,
		double	z0 = 0
	)

Blackman selfWindow

It receives no parameter.

Definition at line 151 of file mask.cpp.

{
    double Xdim2 = XMIPP_MAX(1, (XSIZE(mask) - 1) * (XSIZE(mask) - 1));
    double Ydim2 = XMIPP_MAX(1, (YSIZE(mask) - 1) * (YSIZE(mask) - 1));
    double Zdim2 = XMIPP_MAX(1, (ZSIZE(mask) - 1) * (ZSIZE(mask) - 1));
    FOR_ALL_ELEMENTS_IN_ARRAY3D(mask)
    {
        double r = sqrt((k - z0) * (k - z0) / Zdim2 + (i - y0) * (i - y0) / Xdim2 + (j - x0) * (j - x0) / Ydim2);
        A3D_ELEM(mask, k, i, j) = 0.42 + 0.5 * cos(2 * PI * r) + 0.08 * cos(4 * PI * r);
        if (mode == OUTSIDE_MASK)
            A3D_ELEM(mask, k, i, j) = 1 - A3D_ELEM(mask, k, i, j);
    }
}

BlobCircularMask()

void BlobCircularMask	(	MultidimArray< double > &	mask,
		double	r1,
		blobtype	blob,
		int	mode,
		double	x0 = 0,
		double	y0 = 0,
		double	z0 = 0
	)

Creates a circular mask with blob-shaped edges for already sized masks

The mask is supposed to be resized and with its logical origin already set. A circle placed logically at (x0,y0,z0), by default (0,0,0), is created with the radius indicated. The only two valid modes are INNER_MASK (by default) or OUTSIDE_MASK. When entering the mask is initialiazed to 0 and then the mask is created.

Definition at line 219 of file mask.cpp.

{
    FOR_ALL_ELEMENTS_IN_ARRAY3D(mask)
    {
        double r = sqrt((k - z0) * (k - z0) + (i - y0) * (i - y0) + (j - x0) * (j - x0));
        if (mode == INNER_MASK)
        {
            if (r <= r1)
                A3D_ELEM(mask, k, i, j) = 1;
            else
                A3D_ELEM(mask, k, i, j) = blob_val(r-r1, blob);
        }
        else
        {
            if (r >= r1)
                A3D_ELEM(mask, k, i, j) = 1;
            else
                A3D_ELEM(mask, k, i, j) = blob_val(r1-r, blob);
        }
    }

}

BlobCrownMask()

void BlobCrownMask	(	MultidimArray< double > &	mask,
		double	r1,
		double	r2,
		blobtype	blob,
		int	mode,
		double	x0 = 0,
		double	y0 = 0,
		double	z0 = 0
	)

Creates a crown mask with blob-shaped edges for already sized masks

The mask is supposed to be resized and with its logical origin already set. A circle placed logically at (x0,y0,z0), by default (0,0,0), is created with the two radii indicated. The only two valid modes are INNER_MASK (by default, between the two radii) or OUTSIDE_MASK (the negative of the crown). It is supposed that R1 is smaller than R2.

When entering the mask is initialiazed to 0 and then the mask is created.

Definition at line 278 of file mask.cpp.

{
    MultidimArray<double> aux;
    aux.resize(mask);
    if (mode == INNER_MASK)
    {
        BlobCircularMask(mask, r1, blob,
                         OUTSIDE_MASK, x0, y0, z0);
        BlobCircularMask(aux, r2, blob,
                         INNER_MASK, x0, y0, z0);
        FOR_ALL_ELEMENTS_IN_ARRAY3D(mask)
        {
            A3D_ELEM(mask, k, i, j) *= A3D_ELEM(aux, k, i, j);
        }
    }
    else
    {
        BlobCircularMask(mask, r1, blob,
                         INNER_MASK, x0, y0, z0);
        BlobCircularMask(aux, r2, blob,
                         OUTSIDE_MASK, x0, y0, z0);
        FOR_ALL_ELEMENTS_IN_ARRAY3D(mask)
        {
            A3D_ELEM(mask, k, i, j) += A3D_ELEM(aux, k, i, j);
        }
    }

}

compute_hist_within_binary_mask() [1/2]

template<typename T >

void compute_hist_within_binary_mask	(	const MultidimArray< int > &	mask,
		MultidimArray< T > &	v,
		Histogram1D &	hist,
		int	no_steps
	)

Compute histogram inside mask within its minimum and maximum value (3D)

Given a volume as input, this function returns the histogram of values inside the mask within the minimum and maximum of the volume, in this way all the values in the volume are counted. The volume can be of any numerical type (short int, int, double, ...). The number of steps must always be given.

Definition at line 906 of file mask.h.

{
    T min_val;
    T max_val;
    double avg;
    double stddev;

    computeStats_within_binary_mask(mask, v, min_val, max_val, avg, stddev);
    compute_hist_within_binary_mask(mask, v, hist, min_val, max_val, no_steps);
}

compute_hist_within_binary_mask() [2/2]

template<typename T >

void compute_hist_within_binary_mask	(	const MultidimArray< int > &	mask,
		const MultidimArray< T > &	v,
		Histogram1D &	hist,
		T	min,
		T	max,
		int	no_steps
	)

Compute histogram inside mask within two values (3D)

Given a volume as input, this function returns the histogram of the values inside the mask within two values, the volume values outside this range are not counted. This can be used to avoid the effect of outliers which causes a "compression" in the histogram. The volume can be of any numerical type (short int, int, double, ...). The number of steps must always be given.

Definition at line 928 of file mask.h.

{
    SPEED_UP_tempsInt;
    hist.init(min, max, no_steps);
    FOR_ALL_ELEMENTS_IN_COMMON_IN_ARRAY3D(mask, v)
    if (A3D_ELEM(mask, k, i, j) != 0)
    {
        double value=A3D_ELEM(v, k, i, j);
        INSERT_VALUE(hist,value);
    }
}

computeStats_within_binary_mask() [1/2]

template<typename T1 , typename T >

void computeStats_within_binary_mask	(	const MultidimArray< T1 > &	mask,
		const MultidimArray< T > &	m,
		double &	min_val,
		double &	max_val,
		double &	avg,
		double &	stddev
	)

Compute statistics in the active area

Only the statistics for values in the overlapping between the mask and the volume for those the mask is not 0 are computed.

Definition at line 799 of file mask.h.

{
    SPEED_UP_tempsInt;
    double sum1 = 0;
    double sum2 = 0;
    int N = 0;

    max_val = min_val = DIRECT_A3D_ELEM(m, 0, 0, 0);

    FOR_ALL_ELEMENTS_IN_COMMON_IN_ARRAY3D(mask, m)
    {
        if (A3D_ELEM(mask, k, i, j) > 0)
        {
            N++;

            double aux=A3D_ELEM(m, k, i, j);
            // Minimum and maximum
            if (aux < min_val)
                min_val = aux;
            else if (aux > max_val)
                max_val = aux;

            // cumulative sums for average and standard deviation
            sum1 += aux;
            sum2 += aux*aux;
        }
    }

    // average and standard deviation
    avg  = sum1 / (double) N;
    if (N > 1)
        stddev = sqrt(fabs(sum2 / N - avg * avg) * N / (N - 1));
    else
        stddev = 0;
}

computeStats_within_binary_mask() [2/2]

void computeStats_within_binary_mask ( const MultidimArray< int > &  mask, const MultidimArrayGeneric &  m, double &  min_val, double &  max_val, double &  avg, double &  stddev  )

inline

Definition at line 838 of file mask.h.

{
#define COMPUTESTATS(type) \
computeStats_within_binary_mask(mask,*((MultidimArray<type>*)m.im),min_val,max_val,avg,stddev);

    SWITCHDATATYPE(m.datatype,COMPUTESTATS);

#undef COMPUTESTATS
}

count_with_mask() [1/2]

template<typename T >

int count_with_mask	(	const MultidimArray< int > &	mask,
		const MultidimArray< T > &	m,
		int	mode,
		double	th1,
		double	th2
	)

Count voxels with mask and threshold.

This function returns the number of voxels in the ACTIVE area of an volume with a value:

COUNT_ABOVE: greater or equal than th1 COUNT_BELOW: smaller or equal than th1 COUNT_BETWEEN: smaller or equal than th1 and greater or equal than th2

For complex matrices the absolute value is compared.

Definition at line 983 of file mask.h.

{
    SPEED_UP_tempsInt;
    int N = 0;
    FOR_ALL_ELEMENTS_IN_COMMON_IN_ARRAY3D(mask, m)
    if (A3D_ELEM(mask, k, i, j))
        switch (mode)
        {
        case COUNT_ABOVE:
                        if (A3D_ELEM(m, k, i, j) >= th1)
                            N++;
            break;

        case COUNT_BELOW:
                        if (A3D_ELEM(m, k, i, j) <= th1)
                            N++;
            break;

        case COUNT_BETWEEN:
                        if (A3D_ELEM(m, k, i, j) >= th1 && A3D_ELEM(m, k, i, j) <= th2)
                            N++;
            break;
        }
    return N;
}

count_with_mask() [2/2]

int count_with_mask	(	const MultidimArray< int > &	mask,
		const MultidimArray< std::complex< double > > &	m,
		int	mode,
		double	th1,
		double	th2
	)

Definition at line 1712 of file mask.cpp.

{
    SPEED_UP_tempsInt;
    int N = 0;
    FOR_ALL_ELEMENTS_IN_COMMON_IN_ARRAY3D(mask, m)
    if (A2D_ELEM(mask, i, j))
        switch (mode)
        {
        case COUNT_ABOVE:
                        if (abs(A3D_ELEM(m, k, i, j)) >= th1)
                            N++;
            break;
        case COUNT_BELOW:
                        if (abs(A3D_ELEM(m, k, i, j)) <= th1)
                            N++;
            break;
        case COUNT_BETWEEN:
                        if (abs(A3D_ELEM(m, k, i, j)) >= th1 && abs(A3D_ELEM(m, k, i, j)) <= th2)
                            N++;
            break;
        }
    return N;
}

GaussianMask()

void GaussianMask	(	MultidimArray< double > &	mask,
		double	sigma,
		int	mode = INNER_MASK,
		double	x0 = 0,
		double	y0 = 0,
		double	z0 = 0
	)

Creates a gaussian mask for already sized masks

The mask is supposed to be resized and with its logical origin already set. A circle placed logically at (x0,y0,z0), by default (0,0,0), is created with the radius indicated. The only two valid modes are INNER_MASK (by default) or OUTSIDE_MASK. Inner mask are normal sincs, and outside masks are 1 -gaussian.

When entering the mask is initialiazed to 0 and then the mask is created.

Definition at line 325 of file mask.cpp.

{
    double sigma2 = sigma * sigma;

    double K = 1. / pow(sqrt(2.*PI)*sigma,(double)mask.getDim());

    FOR_ALL_ELEMENTS_IN_ARRAY3D(mask)
    {
        double r2 = (k - z0) * (k - z0) + (i - y0) * (i - y0) + (j - x0) * (j - x0);
        A3D_ELEM(mask, k, i, j) = K * exp(-0.5 * r2 / sigma2);

        if (mode == OUTSIDE_MASK)
            A3D_ELEM(mask, k, i, j) = 1 - A3D_ELEM(mask, k, i, j);
    }
}

invert_binary_mask()

template<typename T >

void invert_binary_mask

(

MultidimArray< T > &

mask

)

Invert binary mask.

0's are converted in 1's and viceversa

Definition at line 1020 of file mask.h.

{
    T* ptr=NULL;
    unsigned long int n;
    FOR_ALL_DIRECT_ELEMENTS_IN_MULTIDIMARRAY_ptr(mask,n,ptr)
    *ptr = 1-(*ptr);
}

KaiserMask()

void KaiserMask	(	MultidimArray< double > &	mask,
		double	delta = 0.01,
		double	Deltaw = 1.0/12.0
	)

Kaiser selfWindow The mask is resized. delta=ripple (in natural units) in the pass band. Deltaw=transition bandwidth (normalized to 1.0).

Definition at line 83 of file mask.cpp.

{
    // Convert Deltaw from a frequency normalized to 1, to a freq. normalized to PI
    Deltaw *= PI;

    // Design Kaiser selfWindow
    double A = -20 * log10(delta);
    int    M = CEIL((A - 8) / (2.285 * Deltaw));
    double beta;
    if (A > 50)
        beta = 0.1102 * (A - 8.7);
    else if (A >= 21)
        beta = 0.5842 * pow(A - 21, 0.4) + 0.07886 * (A - 21);
    else
        beta = 0;

    // "Draw" Kaiser selfWindow
    if (YSIZE(mask)==1 && ZSIZE(mask)==1)
    {
        // 1D
        mask.resize(2*M + 1);
    }
    else if (ZSIZE(mask)==1)
    {
        // 2D
        mask.resize(2*M + 1, 2*M + 1);
    }
    else
    {
        // 3D
        mask.resize(2*M + 1, 2*M + 1, 2*M + 1);
    }

    mask.setXmippOrigin();
    double iI0Beta = 1.0 / bessi0(beta);
    FOR_ALL_ELEMENTS_IN_ARRAY3D(mask)
    {
        double r = sqrt((double)(i * i + j * j + k * k));
        if (r <= M)
            A3D_ELEM(mask, k, i, j) = bessi0(beta * sqrt(1-(r/M)*(r/M))) * iI0Beta;
    }

}

mask2D_4neig()

void mask2D_4neig	(	MultidimArray< int > &	mask,
		int	value = 1,
		int	center = NO_ACTIVATE
	)

Creates a 3x3 mask with value (1 by default) for those 4-neighbours of the central point (0 otherwise).

The parameter center controls whether the center pixel is set to 1 or not

Definition at line 409 of file mask.cpp.

{
    mask.resize(3, 3);
    mask.initZeros();
    mask(0, 1) = mask(1, 0) = mask(1, 2) = mask(2, 1) = value;
    mask(1, 1) = center;

}

mask2D_8neig()

void mask2D_8neig	(	MultidimArray< int > &	mask,
		int	value1 = 1,
		int	value2 = 1,
		int	center = NO_ACTIVATE
	)

Creates a 3x3 mask with value1 for those 4-neighbors of the central point and value2 for the 8 neighbours.

The parameter center controls whether the center pixel is set to 1 or not

Definition at line 417 of file mask.cpp.

{
    mask.resize(3, 3);
    mask.initZeros();
    mask(0, 1) = mask(1, 0) = mask(1, 2) = mask(2, 1) = value1;
    mask(0, 0) = mask(0, 2) = mask(2, 0) = mask(2, 2) = value2;
    mask(1, 1) = center;

}

mask3D_18neig()

void mask3D_18neig	(	MultidimArray< int > &	mask,
		int	value1 = 1,
		int	value2 = 1,
		int	center = NO_ACTIVATE
	)

Creates a 3x3x3 mask with value1 (1 by default) for those 6-neighbors and value2 for the 18 neighbors of the central point (0 otherwise).

The parameter center controls whether the center pixel is set to 1 or not

Definition at line 598 of file mask.cpp.

{
    mask.resize(3, 3, 3);
    mask.initZeros();
    mask(1, 1, 1) = center;
    //Face neighbors
    mask(1, 1, 0) = mask(1, 1, 2) = mask(0, 1, 1) = mask(2, 1, 1) = mask(1, 0, 1) = mask(1, 2, 1) = value1;
    //Edge neighbors
    mask(0, 1, 0) = mask(0, 0, 1) = mask(0, 1, 2) = mask(0, 2, 1) = value2;
    mask(1, 0, 0) = mask(1, 2, 0) = mask(1, 0, 2) = mask(1, 2, 2) = value2;
    mask(2, 1, 0) = mask(2, 0, 1) = mask(2, 1, 2) = mask(2, 2, 1) = value2;


}

mask3D_26neig()

void mask3D_26neig	(	MultidimArray< int > &	mask,
		int	value1 = 1,
		int	value2 = 1,
		int	value3 = 1,
		int	center = NO_ACTIVATE
	)

Creates a 3x3x3 mask with value1 (1 by default) for those 6-neighbors, value2 for the 18 neighbors and value3 for the 26 neighbors of the central point (0 otherwise).

The parameter center controls whether the center pixel is set to 1 or not

Definition at line 612 of file mask.cpp.

{
    mask.resize(3, 3, 3);
    mask.initZeros();
    mask(1, 1, 1) = center;
    //Face neighbors
    mask(1, 1, 0) = mask(1, 1, 2) = mask(0, 1, 1) = mask(2, 1, 1) = mask(1, 0, 1) = mask(1, 2, 1) = value1;
    //Edge neighbors
    mask(0, 1, 0) = mask(0, 0, 1) = mask(0, 1, 2) = mask(0, 2, 1) = value2;
    mask(1, 0, 0) = mask(1, 2, 0) = mask(1, 0, 2) = mask(1, 2, 2) = value2;
    mask(2, 1, 0) = mask(2, 0, 1) = mask(2, 1, 2) = mask(2, 2, 1) = value2;
    //Vertex neighbors
    mask(0, 0, 0) = mask(0, 0, 2) = mask(0, 2, 0) = mask(0, 2, 2) = value3;
    mask(2, 0, 0) = mask(2, 0, 2) = mask(2, 2, 0) = mask(2, 2, 2) = value3;

}

mask3D_6neig()

void mask3D_6neig	(	MultidimArray< int > &	mask,
		int	value = 1,
		int	center = NO_ACTIVATE
	)

Creates a 3x3x3 mask with value (1 by default) for those 6-neighbors of the central point (0 otherwise).

The parameter center controls whether the center pixel is set to 1 or not

Definition at line 589 of file mask.cpp.

{
    mask.resize(3, 3, 3);
    mask.initZeros();
    mask(1, 1, 1) = center;
    mask(1, 1, 0) = mask(1, 1, 2) = mask(0, 1, 1) = mask(2, 1, 1) = mask(1, 0, 1) = mask(1, 2, 1) = value;

}

RaisedCosineMask()

void RaisedCosineMask	(	MultidimArray< double > &	mask,
		double	r1,
		double	r2,
		int	mode = INNER_MASK,
		double	x0 = 0,
		double	y0 = 0,
		double	z0 = 0
	)

Creates a RaisedCosine mask for already sized masks

The mask is supposed to be resized and with its logical origin already set. A circle placed logically at (x0,y0,z0), by default (0,0,0), is created with the radius indicated. The only two valid modes are INNER_MASK (by default) or OUTSIDE_MASK. Inner mask are normal RaisedCosines, and outside masks are 1 - RaisedCosine. When entering, the mask is initialiazed to 0 and then the mask is created.

Definition at line 36 of file mask.cpp.

{
    double K = PI / (r2 - r1);
    double r1_2=r1*r1;
    double r2_2=r2*r2;
    for (int k=STARTINGZ(mask); k<=FINISHINGZ(mask); ++k)
    {
        double k2=(k - z0) * (k - z0);
        for (int i=STARTINGY(mask); i<=FINISHINGY(mask); ++i)
        {
            double i2_k2=k2+(i - y0) * (i - y0);
            for (int j=STARTINGX(mask); j<=FINISHINGX(mask); ++j)
            {
                double r2=i2_k2+(j - x0) * (j - x0);
                if (r2 <= r1_2)
                    A3D_ELEM(mask, k, i, j) = 1;
                else if (r2 < r2_2)
                {
                    double r=sqrt(r2);
                    A3D_ELEM(mask, k, i, j) = 0.5*(1 + cos(K * (r - r1)));
                }
                else
                    A3D_ELEM(mask, k, i, j) = 0;
                if (mode == OUTSIDE_MASK)
                    A3D_ELEM(mask, k, i, j) = 1 - A3D_ELEM(mask, k, i, j);
            }
        }
    }
}

RaisedCrownMask()

void RaisedCrownMask	(	MultidimArray< double > &	mask,
		double	r1,
		double	r2,
		double	pix_width,
		int	mode = INNER_MASK,
		double	x0 = 0,
		double	y0 = 0,
		double	z0 = 0
	)

Creates a RaisedCrown mask for already sized masks

The mask is supposed to be resized and with its logical origin already set. A circle placed logically at (x0,y0), by default (0,0), is created within the two the radii indicated with an extra region of (pix_width) pixels. The only two valid modes are INNER_MASK (by default) or OUTSIDE_MASK. Inner mask are normal RaisedCrowns, and outside masks are 1 - RaisedCrowns. When entering, the mask is initialiazed to 0 and then the mask is created.

Definition at line 67 of file mask.cpp.

{
    RaisedCosineMask(mask, r1 - pix_width, r1 + pix_width, OUTSIDE_MASK, x0, y0, z0);
    MultidimArray<double> aux;
    aux.resize(mask);
    RaisedCosineMask(aux, r2 - pix_width, r2 + pix_width, INNER_MASK, x0, y0, z0);
    FOR_ALL_ELEMENTS_IN_ARRAY3D(mask)
    {
        A3D_ELEM(mask, k, i, j) *= A3D_ELEM(aux, k, i, j);
        if (mode == OUTSIDE_MASK)
            A3D_ELEM(mask, k, i, j) = 1 - A3D_ELEM(mask, k, i, j);
    }
}

rangeAdjust_within_mask()

void rangeAdjust_within_mask	(	const MultidimArray< double > *	mask,
		const MultidimArray< double > &	m1,
		MultidimArray< double > &	m2
	)

Range adjust within binary mask

Make the grey values of m2 fit, in L2 sense, with those in m1. Only the voxels within the mask are used to compute the linear transformation. If no mask is provided then all voxels are used.

Definition at line 1738 of file mask.cpp.

{
    Matrix2D<double> A(2, 2);
    A.initZeros();
    Matrix1D<double> b(2);
    b.initZeros();
    SPEED_UP_tempsInt;
    // Compute Least squares solution
    if (mask == nullptr)
    {
        FOR_ALL_ELEMENTS_IN_COMMON_IN_ARRAY3D(m1, m2)
        {
            A(0, 0) += m2(k, i, j) * m2(k, i, j);
            A(0, 1) += m2(k, i, j);
            A(1, 1) += 1;
            b(0)   += m1(k, i, j) * m2(k, i, j);
            b(1)   += m1(k, i, j);
        }
        A(1, 0) = A(0, 1);
    }
    else
    {
        FOR_ALL_ELEMENTS_IN_COMMON_IN_ARRAY3D(*mask, m2)
        {
            if ((*mask)(k, i, j))
            {
                A(0, 0) += m2(k, i, j) * m2(k, i, j);
                A(0, 1) += m2(k, i, j);
                A(1, 1) += 1;
                b(0)   += m1(k, i, j) * m2(k, i, j);
                b(1)   += m1(k, i, j);
            }
        }
        A(1, 0) = A(0, 1);
    }
    b = A.inv() * b;

    // Apply to m2
    FOR_ALL_ELEMENTS_IN_ARRAY3D(m2) m2(k, i, j) = b(0) * m2(k, i, j) + b(1);
}

SeparableSincKaiserMask2D()

void SeparableSincKaiserMask2D	(	MultidimArray< double > &	mask,
		double	omega,
		double	delta = 0.01,
		double	Deltaw = 1.0/12.0
	)

Creates a 2D separable-sinc-kaiser mask, the mask is resized. This function returns a sinc mask windowed by a Kaiser selfWindow. delta=ripple (in natural units) in the pass band. Deltaw=transition bandwidth (normalized to 1). omega=low pass frequency (normalized to 1).

Definition at line 379 of file mask.cpp.

{
    // Convert Deltaw from a frequency normalized to 1, to a freq. normalized to PI
    Deltaw *= PI;
    omega *= PI;

    // Design Kaiser selfWindow
    double A = -20 * log10(delta);
    double M = CEIL((A - 8) / (2.285 * Deltaw));
    double beta;
    if (A > 50)
        beta = 0.1102 * (A - 8.7);
    else if (A >= 21)
        beta = 0.5842 * pow(A - 21, 0.4) + 0.07886 * (A - 21);
    else
        beta = 0;

    // "Draw" Separable Kaiser Sinc selfWindow
    mask.resize((size_t)(2*M + 1),(size_t)(2*M + 1));
    mask.setXmippOrigin();
    double iI0Beta = 1.0 / bessi0(beta);
    FOR_ALL_ELEMENTS_IN_ARRAY2D(mask)
    {
        mask(i, j) = omega/PI * SINC(omega/PI * i) * omega/PI * SINC(omega/PI * j) *
                     bessi0(beta * sqrt((double)(1 - (i / M) * (i / M)))) * iI0Beta *
                     bessi0(beta * sqrt((double)(1 - (j / M) * (j / M)))) * iI0Beta;
    }
}

SincBlackmanMask()

void SincBlackmanMask	(	MultidimArray< double > &	mask,
		double	omega,
		double	power_percentage,
		double	x0 = 0,
		double	y0 = 0,
		double	z0 = 0
	)

Creates a sinc-blackman mask, the mask is resized

This function returns a sinc mask windowed by a Blackman selfWindow. The selfWindow is designed to cover a certain power of the sinc

Definition at line 166 of file mask.cpp.

{
    MultidimArray<double> blackman;

    int N = CEIL(1 / omega * CEIL(-1 / 2 + 1 / (PI * (1 - power_percentage / 100))));

    if (ZSIZE(mask)==1)
    {
        // 2D
        mask.resize(N, N);
        blackman.resize(N, N);
    }
    else
    {
        // 3D
        mask.resize(N, N, N);
        blackman.resize(N, N, N);
    }
    mask.setXmippOrigin();
    SincMask(mask,omega,INNER_MASK,x0,y0,z0);
    blackman.setXmippOrigin();
    BlackmanMask(blackman);
    mask *= blackman;
}

SincKaiserMask()

void SincKaiserMask	(	MultidimArray< double > &	mask,
		double	omega,
		double	delta = 0.01,
		double	Deltaw = 1.0/12.0
	)

Creates a radial-sinc-kaiser mask, the mask is resized. This function returns a sinc mask windowed by a Kaiser selfWindow. delta=ripple (in natural units) in the pass band. Deltaw=transition bandwidth (normalized to 1). omega=low pass frequency (normalized to 1).

Definition at line 139 of file mask.cpp.

{
    MultidimArray<double> kaiser;
    kaiser.resizeNoCopy(mask);
    KaiserMask(kaiser, delta, Deltaw);
    mask.resize(kaiser);
    mask.setXmippOrigin();
    SincMask(mask, omega*PI, INNER_MASK);
    mask *= kaiser;
}

SincMask()

void SincMask	(	MultidimArray< double > &	mask,
		double	omega,
		int	mode = INNER_MASK,
		double	x0 = 0,
		double	y0 = 0,
		double	z0 = 0
	)

Creates a sinc mask for already sized masks

The mask is supposed to be resized and with its logical origin already set. A circle placed logically at (x0), by default (0), is created with the radius indicated. The only two valid modes are INNER_MASK (by default) or OUTSIDE_MASK. Inner mask are normal sincs, and outside masks are 1 - sinc. When entering the mask is initialiazed to 0 and then the mask is created.

Remind that sinc(w*n) is zero at n=1/w;

Definition at line 127 of file mask.cpp.

{
    FOR_ALL_ELEMENTS_IN_ARRAY3D(mask)
    {
        double r = sqrt( (k - z0) * (k - z0) + (i - y0) * (i - y0) + (j - x0) * (j - x0) );
        A3D_ELEM(mask, k, i, j) = omega/PI * SINC(omega/PI * r);
        if (mode == OUTSIDE_MASK)
            A3D_ELEM(mask, k, i, j) = 1 - A3D_ELEM(mask, k, i, j);
    }
}

Variable Documentation

ACTIVATE

constexpr int ACTIVATE = 1

Definition at line 50 of file mask.h.

COUNT_ABOVE

constexpr int COUNT_ABOVE = 1

Definition at line 942 of file mask.h.

COUNT_BELOW

constexpr int COUNT_BELOW = 2

Definition at line 943 of file mask.h.

COUNT_BETWEEN

constexpr int COUNT_BETWEEN = 3

Definition at line 944 of file mask.h.

INNER_MASK

constexpr int INNER_MASK = 1

Definition at line 47 of file mask.h.

NO_ACTIVATE

constexpr int NO_ACTIVATE = 0

Definition at line 49 of file mask.h.

OUTSIDE_MASK

constexpr int OUTSIDE_MASK = 2

Definition at line 48 of file mask.h.