EMAN::AutoMask3D2Processor Class Reference

Tries to mask out only interesting density. More...

#include <processor.h>

Inheritance diagram for EMAN::AutoMask3D2Processor:

[legend]

Collaboration diagram for EMAN::AutoMask3D2Processor:

[legend]

List of all members.

Public Member Functions
virtual void	process_inplace (EMData *image)
	To process an image in-place.
virtual string	get_name () const
	Get the processor's name.
virtual string	get_desc () const
	Get the descrition of this specific processor.
virtual TypeDict	get_param_types () const
	Get processor parameter information in a dictionary.
Static Public Member Functions
static Processor *	NEW ()

---

Detailed Description

Tries to mask out only interesting density.

Parameters:

	radius	Pixel radius of a ball which is used to seed the flood filling operation
	threshold	An isosurface threshold that suitably encases the mass
	nshells	The number of dilation operations
	nshellsgauss	number of Gaussian pixels to expand, following the dilation operations If true the result of the operation will produce the mask, not the masked volume

Definition at line 4668 of file processor.h.

---

Member Function Documentation

void AutoMask3D2Processor::process_inplace

(

EMData *

image

)

[virtual]

To process an image in-place.

For those processors which can only be processed out-of-place, override this function to just print out some error message to remind user call the out-of-place version.

Parameters:

image

The image to be processed.

Implements EMAN::Processor.

Definition at line 5993 of file processor.cpp.

References abs, EMAN::EMData::get_data(), EMAN::EMData::get_ndim(), EMAN::EMData::get_size(), EMAN::EMData::get_xsize(), EMAN::EMData::get_ysize(), EMAN::EMData::get_zsize(), ImageDimensionException, LOGWARN, EMAN::EMData::mult(), EMAN::Processor::params, EMAN::EMData::process_inplace(), EMAN::Dict::set_default(), EMAN::EMData::set_size(), and EMAN::EMData::update().

{
        if (!image) {
                LOGWARN("NULL Image");
                return;
        }

        if (image->get_ndim() != 3) {
                throw ImageDimensionException("This processor was only ever designed to work on 3D images.");
        }

        /*
         The mask writing functionality was removed to comply with an EMAN2 policy which dictates that file io is not allowed from within a processor
         To get around this just use the return_mask parameter.
        string mask_output = params.set_default("write_mask", "");
        if ( mask_output != "") {
                if (Util::is_file_exist(mask_output) ) throw InvalidParameterException("The mask output file name already exists. Please remove it if you don't need it.");
                if (!EMUtil::is_valid_filename(mask_output)) throw InvalidParameterException("The mask output file name type is invalid or unrecognized");
        }
        */

        int radius = params["radius"];
        float threshold = params["threshold"];
        int nshells = params["nshells"];
        int nshellsgauss = params["nshellsgauss"];

        int nx = image->get_xsize();
        int ny = image->get_ysize();
        int nz = image->get_zsize();
        int nxy=nx*ny;

        EMData *amask = new EMData();
        amask->set_size(nx, ny, nz);

        float *dat = image->get_data();
        float *dat2 = amask->get_data();

        // start with an initial sphere
        int i,j,k;
        size_t l = 0;
        for (k = -nz / 2; k < nz / 2; ++k) {
                for (j = -ny / 2; j < ny / 2; ++j) {
                        for (i = -nx / 2; i < nx / 2; ++i,++l) {
                                if (abs(k) > radius || abs(j) > radius || abs(i) > radius) continue;
                                if ( (k * k + j * j + i * i) > (radius*radius) || dat[l] < threshold) continue;
                                dat2[l] = 1.0f;
                        }
                }
        }

        // iteratively 'flood fills' the map... recursion would be better
        int done=0;
        while (!done) {
                done=1;
                for (k=1; k<nz-1; ++k) {
                        for (j=1; j<ny-1; ++j) {
                                for (i=1; i<nx-1; ++i) {
                                        l=i+j*nx+k*nx*ny;
                                        if (dat2[l]) continue;
                                        if (dat[l]>threshold && (dat2[l-1]||dat2[l+1]||dat2[l+nx]||dat2[l-nx]||dat2[l-nxy]||dat2[l+nxy])) {
                                                dat2[l]=1.0;
                                                done=0;
                                        }
                                }
                        }
                }
        }

        amask->update();

        amask->process_inplace("mask.addshells.gauss", Dict("val1", nshells, "val2", nshellsgauss));

        bool return_mask = params.set_default("return_mask",false);
        if (return_mask) {
                // Yes there is probably a much more efficient way of getting the mask itself, but I am only providing a stop gap at the moment.
                memcpy(dat,dat2,image->get_size()*sizeof(float));
        } else {
                image->mult(*amask);
        }

        // EMAN2 policy is not to allow file io from with a processor
        //if (mask_output != "") {
        //      amask->write_image(mask_output);
        //}


        delete amask;
}

virtual string EMAN::AutoMask3D2Processor::get_name

(

)

const [inline, virtual]

Get the processor's name.

Each processor is identified by a unique name.

Returns:

The processor's name.

Implements EMAN::Processor.

Definition at line 4673 of file processor.h.

                {
                        return "mask.auto3d";
                }

static Processor* EMAN::AutoMask3D2Processor::NEW

(

)

[inline, static]

Definition at line 4678 of file processor.h.

                {
                        return new AutoMask3D2Processor();
                }

virtual string EMAN::AutoMask3D2Processor::get_desc

(

)

const [inline, virtual]

Get the descrition of this specific processor.

This function must be overwritten by a subclass.

Returns:

The description of this processor.

Implements EMAN::Processor.

Definition at line 4683 of file processor.h.

                {
                        return "Tries to mask out only interesting density using something akin to a flood file approach.";
                }

virtual TypeDict EMAN::AutoMask3D2Processor::get_param_types

(

)

const [inline, virtual]

Get processor parameter information in a dictionary.

Each parameter has one record in the dictionary. Each record contains its name, data-type, and description.

Returns:

A dictionary containing the parameter info.

Reimplemented from EMAN::Processor.

Definition at line 4688 of file processor.h.

References EMAN::EMObject::BOOL, EMAN::EMObject::FLOAT, EMAN::EMObject::INT, and EMAN::TypeDict::put().

                {
                        TypeDict d;
                        d.put("radius", EMObject::INT,"Pixel radius of a ball which is used to seed the flood filling operation.");
                        d.put("threshold", EMObject::FLOAT, "An isosurface threshold that suitably encases the mass.");
                        d.put("nshells", EMObject::INT, "The number of dilation operations");
                        d.put("nshellsgauss", EMObject::INT, "number of Gaussian pixels to expand, following the dilation operations");
                        d.put("return_mask", EMObject::BOOL, "If true the result of the operation will produce the mask, not the masked volume.");
                        return d;

                }

---

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

• processor.h
• processor.cpp