Thinning a binary map to skelton using the Zhang-Suen thinning algorithm. More...

#include <processor.h>

Inheritance diagram for EMAN::BwThinningProcessor:

Collaboration diagram for EMAN::BwThinningProcessor:

[legend]

Public Member Functions
virtual void	process_inplace (EMData *image)
	To process an image in-place. More...

virtual EMData *	process (const EMData *const image)
	To proccess an image out-of-place. More...

virtual string	get_name () const
	Get the processor's name. More...

string	get_desc () const
	Get the descrition of this specific processor. More...

int	process_pixel (float data, float array, int step)

virtual TypeDict	get_param_types () const
	Get processor parameter information in a dictionary. More...

Public Member Functions inherited from EMAN::Processor
virtual	~Processor ()

virtual void	process_list_inplace (vector< EMData * > &images)
	To process multiple images using the same algorithm. More...

virtual Dict	get_params () const
	Get the processor parameters in a key/value dictionary. More...

virtual void	set_params (const Dict &new_params)
	Set the processor parameters using a key/value dictionary. More...

Static Public Member Functions
static Processor *	NEW ()

Static Public Member Functions inherited from EMAN::Processor
static string	get_group_desc ()
	Get the description of this group of processors. More...

static void	EMFourierFilterInPlace (EMData *fimage, Dict params)
	Compute a Fourier-filter processed image in place. More...

static EMData *	EMFourierFilter (EMData *fimage, Dict params)
	Compute a Fourier-processor processed image without altering the original image. More...

Static Public Attributes
static const string	NAME = "morph.thin"

Additional Inherited Members
Public Types inherited from EMAN::Processor
enum	fourier_filter_types { TOP_HAT_LOW_PASS , TOP_HAT_HIGH_PASS , TOP_HAT_BAND_PASS , TOP_HOMOMORPHIC , GAUSS_LOW_PASS , GAUSS_HIGH_PASS , GAUSS_BAND_PASS , GAUSS_INVERSE , GAUSS_HOMOMORPHIC , BUTTERWORTH_LOW_PASS , BUTTERWORTH_HIGH_PASS , BUTTERWORTH_HOMOMORPHIC , KAISER_I0 , KAISER_SINH , KAISER_I0_INVERSE , KAISER_SINH_INVERSE , SHIFT , TANH_LOW_PASS , TANH_HIGH_PASS , TANH_HOMOMORPHIC , TANH_BAND_PASS , RADIAL_TABLE , CTF_ }
	Fourier filter Processor type enum. More...

Protected Attributes inherited from EMAN::Processor
Dict	params

Detailed Description

Thinning a binary map to skelton using the Zhang-Suen thinning algorithm.

(1984, ACM)

Author: : Muyuan Chen

Date: : 03/2015

Definition at line 9538 of file processor.h.

Member Function Documentation

◆ get_desc()

string EMAN::BwThinningProcessor::get_desc ( ) const

inlinevirtual

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 9552 of file processor.h.

                {
                        return "Thinning a binary map to skelton using the Zhang-Suen thinning algorithm.";
                }

◆ get_name()

virtual string EMAN::BwThinningProcessor::get_name ( ) const

inlinevirtual

Get the processor's name.

Each processor is identified by a unique name.

Returns: The processor's name.

Implements EMAN::Processor.

Definition at line 9544 of file processor.h.

                {
                        return NAME;
                }

References NAME.

◆ get_param_types()

virtual TypeDict EMAN::BwThinningProcessor::get_param_types ( ) const

inlinevirtual

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 9557 of file processor.h.

                {
                        TypeDict d;
                        d.put("thresh", EMObject::FLOAT, "The threshold to binarize the map.");
                        d.put("verbose", EMObject::INT, "Verbose");
                        d.put("preserve_value", EMObject::BOOL, "The value on the skeleton is the same as the original map.");
                        d.put("ntimes", EMObject::INT, "Number of iterations in the thinning process. Default: -1 (perform thinning until the image is skeltonized");
                        return d;
                }

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

◆ NEW()

static Processor * EMAN::BwThinningProcessor::NEW ( )

inlinestatic

Definition at line 9548 of file processor.h.

                {
                        return new BwThinningProcessor();
                }

◆ process()

EMData * BwThinningProcessor::process ( const EMData *const image )

virtual

To proccess an image out-of-place.

For those processors which can only be processed out-of-place, override this function to give the right behavior.

Parameters

image The image will be copied, actual process happen on copy of image.

Returns: the image processing result, may or may not be the same size of the input image

Reimplemented from EMAN::Processor.

Definition at line 14651 of file processor.cpp.

{
 
        EMData* imageCp= image -> copy();
        process_inplace(imageCp);
 
        return imageCp;
}

References copy(), and process_inplace().

◆ process_inplace()

void BwThinningProcessor::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 14660 of file processor.cpp.

                                                       {
 
        int nx = image->get_xsize();
        int ny = image->get_ysize();
        int nz = image->get_zsize();
 
        float threshold=params.set_default("thresh",0);
        int ntimes=params.set_default("ntimes",-1);
        int verbose=params.set_default("verbose",0);
        int preserve=params.set_default("preserve_value",false);
        float array[9];
        int n=1;
        EMData* imageCp;
        if (preserve)
                imageCp= image -> copy();
        float *data = image->get_data();
        size_t total_size = (size_t)nx * (size_t)ny * (size_t)nz;
        int nxy = nx * ny;
        // binarize image and deal with boundary points first
        float *data2 = new float[total_size];
        for (int k=0; k<nz; k++){
                if (verbose>0)
                        printf("layer %d \n",k);
                size_t knxy = (size_t)k * nxy;
                for (int j=0; j<ny; j++){
                        int jnx = j * nx;
                        for (int i=0; i<nx; i++){
                                if(i==0 || i==nx-1 || j==0 || j==ny-1)
                                        data[i+jnx+knxy]=0;
                                else{
                                        if (data[i+jnx+knxy]>threshold)
                                                data[i+jnx+knxy]=1;
                                        else
                                                data[i+jnx+knxy]=0;
                                }
                        }
                }
 
                int allt=ntimes;
                if (ntimes<0){  // thin to skeleton
                        allt=65535;
                }
                // thinning
                int cg;
                for (int nt=0; nt<allt; nt++){
                        cg=0;
                        for (int st = 0; st<2; st++){
                                memcpy(data2, data, total_size * sizeof(float));
                                for (int j = n; j < ny - n; j++) {
                                        int jnx = j * nx;
                                        for (int i = n; i < nx - n; i++) {
                                                size_t s = 0;
                                                for (int i2 = i - n; i2 <= i + n; i2++) {
                                                        for (int j2 = j - n; j2 <= j + n; j2++) {
                                                                array[s] = data2[i2 + j2 * nx+knxy];
                                                                ++s;
                                                        }
                                                }
 
                                                cg+=process_pixel(&data[i + jnx+knxy ], array, st);
                                        }
                                }
                        }
                        if (verbose>1)
                                printf("\t Iter %d, \t %d pixels changed\n",nt,cg);
                        if(cg==0)
                                break;
                }
 
                // remove corner pixels when doing skeletonization
                if (ntimes<0){
                        cg=0;
                        memcpy(data2, data, total_size * sizeof(float));
                        for (int j = n; j < ny - n; j++) {
                                int jnx = j * nx;
                                for (int i = n; i < nx - n; i++) {
                                        size_t s = 0;
                                        for (int i2 = i - n; i2 <= i + n; i2++) {
                                                for (int j2 = j - n; j2 <= j + n; j2++) {
                                                        array[s] = data2[i2 + j2 * nx+knxy];
                                                        ++s;
                                                }
                                        }
 
                                        cg+=process_pixel(&data[i + jnx+knxy ], array, 2);
                                }
                        }
                }
                if (verbose>1)
                        printf("\t %d corner pixels\n",cg);
        }
        image->update();
 
        if( data2 )
        {
                delete[]data2;
                data2 = 0;
        }
 
        if (preserve){
                image->mult(*imageCp);
                delete imageCp;
        }
 
}

References copy(), EMAN::Processor::params, process_pixel(), and EMAN::Dict::set_default().

Referenced by process().

◆ process_pixel()

int BwThinningProcessor::process_pixel	(	float *	data,
		float *	array,
		int	step
	)

Definition at line 14767 of file processor.cpp.

                                                                         {
 
        if (*data==0){
                return 0;
        }
        int bp=-1; // number of 1 neighbors, not counting itself
        for (int i=0; i<9; i++){
                if (array[i]>0)
                        bp++;
        }
        if (bp<2 || bp>6){
                return 0;
        }
        int ap=0; // number of transitions from 0 to 1
        int order[9]={0,1,2,5,8,7,6,3,0};
        for (int i=0; i<8; i++){
                if (array[order[i]]==0 && array[order[i+1]]>0){
                        ap++;
                }
        }
        if (ap!=1 && step<2)
                return 0;
 
        if (step==0){
                if(array[order[1]]*array[order[3]]*array[order[5]]>0)
                        return 0;
                if(array[order[3]]*array[order[5]]*array[order[7]]>0)
                        return 0;
        }
 
        if (step==1){
                if(array[order[1]]*array[order[3]]*array[order[7]]>0)
                        return 0;
                if(array[order[1]]*array[order[5]]*array[order[7]]>0)
                        return 0;
        }
 
        if (step==2){
                if (bp==2){
                        if(array[order[1]]*array[order[3]]>0
                        || array[order[3]]*array[order[5]]>0
                        || array[order[5]]*array[order[7]]>0
                        || array[order[7]]*array[order[1]]>0
                        ){
                                *data=0;
                                return 1;
                        }
                        else{
                                return 0;
                        }
                }
                if (ap==2 ){
                        if(array[order[1]]*array[order[3]]>0
                        || array[order[3]]*array[order[5]]>0
                        ){
                                *data=0;
                                return 1;
                        }
                        else{
                                return 0;
                        }
                }
                return 0;
        }
 
        *data=0;
        return 1;
 
}

Referenced by process_inplace().

Member Data Documentation

◆ NAME

const string BwThinningProcessor::NAME = "morph.thin"

static

Definition at line 9566 of file processor.h.

Referenced by get_name().

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

Public Member Functions

Static Public Member Functions

Static Public Attributes

Additional Inherited Members

Detailed Description

Member Function Documentation

◆ get_desc()

◆ get_name()

◆ get_param_types()

◆ NEW()

◆ process()

◆ process_inplace()

◆ process_pixel()

Member Data Documentation

◆ NAME