WaveletFilter Class Reference

#include <denoise.h>

Inheritance diagram for WaveletFilter:

Collaboration diagram for WaveletFilter:

Public Types
enum	DenoisingType {   REMOVE_SCALE, SOFT_THRESHOLDING, BAYESIAN, ADAPTIVE_SOFT,   CENTRAL }

Public Member Functions
void	readParams (XmippProgram *program)
	WaveletFilter ()
void	produceSideInfo ()
void	show ()
void	apply (MultidimArray< double > &img)
void	denoiseAvgBayesian (MultidimArray< double > &vol)
Public Member Functions inherited from XmippFilter
virtual	~XmippFilter ()

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

Public Attributes
String	DWT_type
DenoisingType	denoising_type
int	scale
int	output_scale
double	threshold
int	R
double	SNR0
double	SNRF
bool	white_noise
bool	adjust_range
int	verbose
bool	dont_denoise
Matrix1D< double >	estimatedS

Detailed Description

Parameters for denoise program

Definition at line 36 of file denoise.h.

Member Enumeration Documentation

DenoisingType

enum WaveletFilter::DenoisingType

Enumerator
REMOVE_SCALE
SOFT_THRESHOLDING
BAYESIAN
ADAPTIVE_SOFT
CENTRAL

Definition at line 39 of file denoise.h.

    {
        REMOVE_SCALE,
        SOFT_THRESHOLDING,
        BAYESIAN,
        ADAPTIVE_SOFT,
        CENTRAL
    } DenoisingType;

Constructor & Destructor Documentation

WaveletFilter()

WaveletFilter::WaveletFilter

(

)

Empty constructor

Definition at line 32 of file denoise.cpp.

{
    DWT_type = "DAUB12";
    denoising_type = REMOVE_SCALE;
    scale = 0;
    output_scale = 0;
    threshold = 50;
    R = -1;
    SNR0 = 1.0 / 10;
    SNRF = 1.0 / 5;
    white_noise = false;
    adjust_range = true;
    verbose = 0;
    dont_denoise = false;
}

Member Function Documentation

apply()

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

virtual

Denoise an image.

Implements XmippFilter.

Definition at line 149 of file denoise.cpp.

{
    if (img.getDim()==2)
    {
        // 2D image denoising
        if (denoising_type == BAYESIAN && adjust_range)
            img.rangeAdjust(0, 1);

        double size2 = log10((double)XSIZE(img)) / log10(2.0);
        if (ABS(size2 - ROUND(size2)) > 1e-6)
            REPORT_ERROR(ERR_MULTIDIM_SIZE, "Input image must be of a size power of 2");
        size2 = log10((double)YSIZE(img)) / log10(2.0);
        if (ABS(size2 - ROUND(size2)) > 1e-6)
            REPORT_ERROR(ERR_MULTIDIM_SIZE, "Input image must be of a size power of 2");
        DWT(img, img);
        Histogram1D hist;
        switch (denoising_type)
        {
        case REMOVE_SCALE:
            clean_quadrant2D(img, scale, "01");
            clean_quadrant2D(img, scale, "10");
            clean_quadrant2D(img, scale, "11");
            break;
        case SOFT_THRESHOLDING:
            compute_hist(img, hist, 100);
            soft_thresholding(img, hist.percentil(threshold));
            break;
        case BAYESIAN:
            estimatedS = bayesian_wiener_filtering2D(img, scale, SNR0, SNRF,
                         white_noise, 0, !dont_denoise);
            break;
        case ADAPTIVE_SOFT:
            adaptive_soft_thresholding2D(img, scale);
            break;
        case CENTRAL:
            DWT_keep_central_part(img, R);
            break;
        }
            if (output_scale != 0)
            {
                auto reduction = (int)pow(2.0, output_scale);
                img.resize(YSIZE(img) / reduction, XSIZE(img) / reduction);
            }
            IDWT(img, img);
    }
    else
    {
        // 3D image denoising
        double size2 = log10((double)XSIZE(img)) / log10(2.0);
        if (ABS(size2 - ROUND(size2)) > 1e-6)
            REPORT_ERROR(ERR_MULTIDIM_SIZE, "Input volume must be of a size power of 2");
        size2 = log10((double)YSIZE(img)) / log10(2.0);
        if (ABS(size2 - ROUND(size2)) > 1e-6)
            REPORT_ERROR(ERR_MULTIDIM_SIZE, "Input volume must be of a size power of 2");
        size2 = log10((double)ZSIZE(img)) / log10(2.0);
        if (ABS(size2 - ROUND(size2)) > 1e-6)
            REPORT_ERROR(ERR_MULTIDIM_SIZE, "Input volume must be of a size power of 2");

        DWT(img, img);
        Histogram1D hist;
        switch (denoising_type)
        {
        case REMOVE_SCALE:
            clean_quadrant3D(img, scale, "001");
            clean_quadrant3D(img, scale, "010");
            clean_quadrant3D(img, scale, "011");
            clean_quadrant3D(img, scale, "100");
            clean_quadrant3D(img, scale, "101");
            clean_quadrant3D(img, scale, "110");
            clean_quadrant3D(img, scale, "111");
            break;
        case SOFT_THRESHOLDING:
            compute_hist(img, hist, 100);
            soft_thresholding(img, hist.percentil(threshold));
            break;
        case BAYESIAN:
            estimatedS = bayesian_wiener_filtering3D(img, scale, SNR0, SNRF,
                         white_noise, verbose, !dont_denoise);
            break;
        case ADAPTIVE_SOFT:
            std::cout << "Adaptive soft-thresholding not implemented for imgumes\n";
            break;
        case CENTRAL:
            std::cout << "Keep central part not implemented for volumes\n";
            break;
        }

        if (output_scale != 0)
        {
            auto reduction = (int)pow(2.0, output_scale);
            img.resizeNoCopy(ZSIZE(img) / reduction, YSIZE(img) / reduction, XSIZE(img) / reduction);
        }
        IDWT(img, img);

    }
}

defineParams()

void WaveletFilter::defineParams ( XmippProgram *  program )

static

Definition at line 49 of file denoise.cpp.

{
    program->addParamsLine("== Wavelet ==");
    program->addParamsLine("  [--wavelet <DWT_type=DAUB12> <mode=remove_scale>]   : Different types of filters using wavelets");
    program->addParamsLine("    where <DWT_type>");
    program->addParamsLine("       DAUB4 DAUB12 DAUB20    : Discrete Wavelet Transform");
    program->addParamsLine("    where <mode>");
    program->addParamsLine("       remove_scale");
    program->addParamsLine("       bayesian <SNR0=0.1> <SNRF=0.2> : Smallest(SNR0) and largest(SNRF) SNR.");
    program->addParamsLine("       soft_thresholding");
    program->addParamsLine("       adaptive_soft");
    program->addParamsLine("       central");
    program->addParamsLine("    alias -w;");
    program->addParamsLine("  [--scale+ <s=0>]             : scale");
    program->addParamsLine("  [--output_scale+ <s=0>]      : output_scale");
    program->addParamsLine("  [--th+ <th=50>]              : threshold of values (%) to remove");
    program->addParamsLine("  [-R+ <r=-1>]                 : Radius to keep, by default half the size");
    program->addParamsLine("  [--white_noise+]             : Select if the noise is white. Used by Bayesian filter.");
}

denoiseAvgBayesian()

void WaveletFilter::denoiseAvgBayesian

(

MultidimArray< double > &

vol

)

Denoise a volume using a precalculated estimate of the bayesian parameters.

Definition at line 246 of file denoise.cpp.

{
    DWT(vol, vol);
    bayesian_wiener_filtering3D(vol, scale, estimatedS);

    if (output_scale != 0)
    {
        auto reduction = (int)pow(2.0, output_scale);
        vol.resizeNoCopy(ZSIZE(vol) / reduction, YSIZE(vol) / reduction, XSIZE(vol) / reduction);
    }
    IDWT(vol, vol);
}

produceSideInfo()

void WaveletFilter::produceSideInfo

(

)

Produce side info.

The DWT type is translated and set

Definition at line 103 of file denoise.cpp.

{
    if (DWT_type == "DAUB4")
        set_DWT_type(DAUB4);
    else if (DWT_type == "DAUB12")
        set_DWT_type(DAUB12);
    else if (DWT_type == "DAUB20")
        set_DWT_type(DAUB20);
    else
        REPORT_ERROR(ERR_VALUE_INCORRECT, "Unknown DWT type");
}

readParams()

void WaveletFilter::readParams ( XmippProgram *  program )

virtual

Read params from a program

Reimplemented from XmippFilter.

Definition at line 70 of file denoise.cpp.

{

    DWT_type = program->getParam("--wavelet", 0);
    String mode = program->getParam("--wavelet", 1);

    if (mode == "remove_scale")
        denoising_type = REMOVE_SCALE;
    else if (mode == "soft_thresholding")
        denoising_type = SOFT_THRESHOLDING;
    else if (mode == "bayesian")
    {
        SNR0 = program->getDoubleParam("--wavelet", 2);
        SNRF = program->getDoubleParam("--wavelet", 3);
        denoising_type = BAYESIAN;
    }
    else if (mode == "adaptive_soft")
        denoising_type = ADAPTIVE_SOFT;
    else if (mode == "central")
        denoising_type = CENTRAL;
    else
        REPORT_ERROR(ERR_DEBUG_IMPOSIBLE, "Bad argument type, this couldn't happens, check arguments parser!!!");

    scale = program->getIntParam("--scale");
    output_scale = program->getIntParam("--output_scale");
    threshold = program->getDoubleParam("--th");
    R = program->getIntParam("-R");
    white_noise = program->checkParam("--white_noise");
    verbose = program->verbose;
    produceSideInfo();
}

show()

void WaveletFilter::show ( )

virtual

Show some info before running

Show specific options

Reimplemented from XmippFilter.

Definition at line 116 of file denoise.cpp.

{
    if (!verbose)
        return;
    std::cout << "DWT type: " << DWT_type << std::endl;
    std::cout << "Denoising: ";
    switch (denoising_type)
    {
    case REMOVE_SCALE:
        std::cout << " Remove scale " << scale << std::endl;
        break;
    case SOFT_THRESHOLDING:
        std::cout << " Soft thresholding " << threshold << std::endl;
        break;
    case BAYESIAN:
        std::cout << " Bayesian\n";
        std::cout << " SNR between " << SNR0 << " and " << SNRF << std::endl
        << " up to scale " << scale << std::endl;
        if (white_noise)
            std::cout << " Imposing white noise\n";
        break;
    case ADAPTIVE_SOFT:
        std::cout << " Adaptive soft thresholding\n";
        break;
    case CENTRAL:
        std::cout << " Keeping central part " << R << " pixels\n";
        break;
    }
    std::cout << "Output scale: " << output_scale << std::endl;
}

Member Data Documentation

adjust_range

bool WaveletFilter::adjust_range

Adjust range in Bayesian denoising.

Definition at line 99 of file denoise.h.

denoising_type

DenoisingType WaveletFilter::denoising_type

Denoising type.

Valid types are REMOVE_SCALE, SOFT_THRESHOLDING, BAYESIAN, ADAPTIVE_SOFT, CENTRAL.

Definition at line 59 of file denoise.h.

dont_denoise

bool WaveletFilter::dont_denoise

Don't denoise.

This is used in the Bayesian method, where the estimatedS parameters can be averaged.

Definition at line 111 of file denoise.h.

DWT_type

String WaveletFilter::DWT_type

Wavelet type.

Valid types DAUB4, DAUB12, DAUB20

Definition at line 52 of file denoise.h.

estimatedS

Matrix1D< double > WaveletFilter::estimatedS

EstimatedS of the Bayesian method.

Definition at line 119 of file denoise.h.

output_scale

int WaveletFilter::output_scale

Output scale.

All wavelet coefficients up to this output scale will be removed. Thus, the output image is reduced by a factor that is related to this output scale. For instance, if the output scale is 0, then no reduction is done. If the output scale is 1, then the output image is reduced by 1/2, if the output scale is 2, then it is reduced by 1/4, ...

Definition at line 75 of file denoise.h.

R

int WaveletFilter::R

Radius for central

Definition at line 83 of file denoise.h.

scale

int WaveletFilter::scale

Scale to which the denoising is applied.

It is used by remove scale, adaptive soft

Definition at line 65 of file denoise.h.

SNR0

double WaveletFilter::SNR0

Smallest SNR

Definition at line 87 of file denoise.h.

SNRF

double WaveletFilter::SNRF

Largest SNR

Definition at line 91 of file denoise.h.

threshold

double WaveletFilter::threshold

Threshold for soft thresholding.

Definition at line 79 of file denoise.h.

verbose

int WaveletFilter::verbose

Verbosity used by denoiser. By default will be 0, programs using denoiser should set this

Definition at line 104 of file denoise.h.

white_noise

bool WaveletFilter::white_noise

White noise

Definition at line 95 of file denoise.h.

---

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

• xmipp/libraries/reconstruction/denoise.h
• xmipp/libraries/reconstruction/denoise.cpp