RetinexFilter Class Reference

#include <filters.h>

Inheritance diagram for RetinexFilter:

Collaboration diagram for RetinexFilter:

Public Member Functions
void	readParams (XmippProgram *program)
void	apply (MultidimArray< double > &img)
void	laplacian (const MultidimArray< double > &img, MultidimArray< std::complex< double > > &fimg, bool direct)
Public Member Functions inherited from XmippFilter
virtual	~XmippFilter ()
virtual void	show ()

Static Public Member Functions
static void	defineParams (XmippProgram *program)

Public Attributes
double	percentile
double	eps
Image< int > *	mask

Detailed Description

Definition at line 1596 of file filters.h.

Member Function Documentation

apply()

void RetinexFilter::apply ( MultidimArray< double > &  img )

virtual

Apply the filter to an image or volume

Implements XmippFilter.

Definition at line 3902 of file filters.cpp.

{
    FourierTransformer fft;
    MultidimArray< std::complex<double> > fimg;

    // Apply forward Laplacian
    fft.FourierTransform(img,fimg,false);
    laplacian(img,fimg,true);
    fft.inverseFourierTransform();

    // Compute the threshold outside the mask
    double *sortedValues=nullptr;
    size_t Nsorted=0;
    if (mask==nullptr)
    {
        Nsorted=MULTIDIM_SIZE(img);
        sortedValues=new double[Nsorted];
        FOR_ALL_DIRECT_ELEMENTS_IN_MULTIDIMARRAY(img)
            sortedValues[n]=fabs(DIRECT_MULTIDIM_ELEM(img,n));
    }
    else
    {
        const MultidimArray<int> &mmask=(*mask)();
        FOR_ALL_DIRECT_ELEMENTS_IN_MULTIDIMARRAY(img)
            if (DIRECT_MULTIDIM_ELEM(mmask,n)==0)
               Nsorted+=1;

        sortedValues=new double[Nsorted];
        size_t i=0;
        FOR_ALL_DIRECT_ELEMENTS_IN_MULTIDIMARRAY(img)
            if (DIRECT_MULTIDIM_ELEM(mmask,n)==0)
                 sortedValues[i++]=fabs(DIRECT_MULTIDIM_ELEM(img,n));
    }
    std::sort(sortedValues,sortedValues+Nsorted);
    double threshold=sortedValues[(size_t)(percentile*Nsorted)];
    delete[] sortedValues;

    // Apply threshold
    FOR_ALL_DIRECT_ELEMENTS_IN_MULTIDIMARRAY(img)
        if (fabs(DIRECT_MULTIDIM_ELEM(img,n))<threshold)
            DIRECT_MULTIDIM_ELEM(img,n)=0.0;

    fft.FourierTransform(img,fimg,false);
    laplacian(img,fimg,false);
    fft.inverseFourierTransform();
}

defineParams()

void RetinexFilter::defineParams ( XmippProgram *  program )

static

Define the parameters for use inside an Xmipp program

Definition at line 3835 of file filters.cpp.

{
    program->addParamsLine("== Retinex ==");
    program->addParamsLine(
        "  [ --retinex <percentile=0.9> <mask_file=\"\"> <eps=1>] : Retinex filter, remove a given percentile of the");
    program->addParamsLine("         : Laplacian within the mask, epsilon controls the behaviour at low frequency");
}

laplacian()

void RetinexFilter::laplacian	(	const MultidimArray< double > &	img,
		MultidimArray< std::complex< double > > &	fimg,
		bool	direct
	)

Compute Laplacian

Definition at line 3857 of file filters.cpp.

{
    if (ZSIZE(img)>1)
    {
        Matrix1D<double> w(3);
        for (size_t k=0; k<ZSIZE(fimg); k++)
        {
            FFT_IDX2DIGFREQ(k,ZSIZE(img),ZZ(w));
            double filter_k=6+eps-2*cos(TWOPI*ZZ(w));
            for (size_t i=0; i<YSIZE(fimg); i++)
            {
                FFT_IDX2DIGFREQ(i,YSIZE(img),YY(w));
                double filter_ki=filter_k-2*cos(TWOPI*YY(w));
                for (size_t j=0; j<XSIZE(fimg); j++)
                {
                    FFT_IDX2DIGFREQ(j,XSIZE(img),XX(w));
                    double filter_kij=filter_ki-2*cos(TWOPI*XX(w));
                    if (!direct && filter_kij>0)
                        filter_kij=1.0/filter_kij;
                    DIRECT_A3D_ELEM(fimg,k,i,j)*=filter_kij;
                }
            }
        }
    }
    else
    {
        Matrix1D<double> w(2);
        for (size_t i=0; i<YSIZE(fimg); i++)
        {
            FFT_IDX2DIGFREQ(i,YSIZE(img),YY(w));
            double filter_i=4+eps-2*cos(TWOPI*YY(w));
            for (size_t j=0; j<XSIZE(fimg); j++)
            {
                FFT_IDX2DIGFREQ(j,XSIZE(img),XX(w));
                double filter_ij=filter_i-2*cos(TWOPI*XX(w));
                if (!direct && filter_ij>0)
                    filter_ij=1.0/filter_ij;
                DIRECT_A2D_ELEM(fimg,i,j)*=filter_ij;
            }
        }
    }
}

readParams()

void RetinexFilter::readParams ( XmippProgram *  program )

virtual

Read from program command line

Reimplemented from XmippFilter.

Definition at line 3844 of file filters.cpp.

{
    percentile = program->getDoubleParam("--retinex",0);
    String fnMask = program->getParam("--retinex",1);
    if (fnMask=="")
        mask = nullptr;
    else
    {
        mask = new Image<int>;
        mask->read(fnMask);
    }
    eps = program->getDoubleParam("--retinex",2);
}

Member Data Documentation

eps

double RetinexFilter::eps

Definition at line 1600 of file filters.h.

mask

Image<int>* RetinexFilter::mask

Definition at line 1601 of file filters.h.

percentile

double RetinexFilter::percentile

Definition at line 1599 of file filters.h.

---

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

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