EMAN::WatershedProcessor Class Reference

'paints' a circle into the image at x,y,z with values inside r1 set to v1, values between r1 and r2 will be set to a value between v1 and v2, and values outside r2 will be unchanged More...

#include <processor.h>

Inheritance diagram for EMAN::WatershedProcessor:

[legend]

Collaboration diagram for EMAN::WatershedProcessor:

[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 ()
Static Public Attributes
static const string	NAME = "watershed"
Private Member Functions
vector< Vec3i >	watershed (EMData *mask, EMData *image, const float &threshold, const Vec3i &cordinate, const int mask_value)
vector< Vec3i >	find_region (EMData *mask, const vector< Vec3i > &coords, const int mask_value, vector< Vec3i > &region)

---

Detailed Description

'paints' a circle into the image at x,y,z with values inside r1 set to v1, values between r1 and r2 will be set to a value between v1 and v2, and values outside r2 will be unchanged

Parameters:

	xpoints	x coordinates
	ypoints	y coordinates
	zpoints	z coordinates
	minval	min value

Definition at line 5415 of file processor.h.

---

Member Function Documentation

void WatershedProcessor::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 1239 of file processor.cpp.

References copy(), find_region(), EMAN::EMData::get_data(), EMAN::EMData::get_size(), EMAN::Processor::params, EMAN::EMData::set_value_at(), EMAN::EMData::to_zero(), EMAN::EMData::update(), v, watershed(), EMAN::EMData::write_image(), x, and y.

                                                       {
        vector<float> xpoints = params["xpoints"];
        vector<float> ypoints = params["ypoints"];
        vector<float> zpoints = params["zpoints"];

        vector<int> x(xpoints.begin(),xpoints.end());
        vector<int> y(ypoints.begin(),ypoints.end());
        vector<int> z(zpoints.begin(),zpoints.end());


        // throw if vector lengths are unequal

//      float maxval = -99999;
        /*
        for(unsigned int i = 0; i < xpoints.size(); ++i) {
                float val = image->get_value_at(x[i],y[i],z[i]);
                if (val > maxval) {
                        maxval = val;
                }
        }*/

        float minval = params["minval"];

        EMData* mask = new EMData(*image);
        mask->to_zero();

        // Set the original mask values
        for(unsigned int i = 0; i < xpoints.size(); ++i) {
                try {
                        mask->set_value_at(x[i],y[i],z[i], (float)(i+1));
                } catch (...) {
                        continue;
                }
        }
        mask->write_image("seeds2.mrc");
//      int dis = 500;
//      float dx = (maxval-minval)/((float) dis - 1);


//      for(int i = 0; i < dis; ++i) {
//              float val = maxval-i*dx;

                while( true ) {
                        bool cont= false;
                        for(unsigned int j = 0; j < xpoints.size(); ++j)
                        {

                                Vec3i coord(x[j],y[j],z[j]);
                                vector<Vec3i> region;
                                region.push_back(coord);
                                vector<Vec3i> find_region_input = region;
                                while (true) {
                                        vector<Vec3i> v = find_region(mask,find_region_input, j+1, region);
                                        if (v.size() == 0 ) break;
                                        else find_region_input = v;
                                }

                                vector<Vec3i> tmp(region.begin(),region.end());
                                region.clear();
                                for(vector<Vec3i>::const_iterator it = tmp.begin(); it != tmp.end(); ++it ) {
                                        vector<Vec3i> tmp2 = watershed(mask, image, minval, *it, j+1);
                                        copy(tmp2.begin(),tmp2.end(),back_inserter(region));
                                }
                                if (region.size() != 0) cont = true;
                        }

                        if (!cont) break;
                }
//      }

        memcpy(image->get_data(),mask->get_data(),sizeof(float)*image->get_size());
        image->update();
}

virtual string EMAN::WatershedProcessor::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 5420 of file processor.h.

References EMAN::NormalizeUnitSumProcessor::NAME.

                {
                        return NAME;
                }

static Processor* EMAN::WatershedProcessor::NEW

(

)

[inline, static]

Definition at line 5425 of file processor.h.

                {
                        return new WatershedProcessor();
                }

virtual string EMAN::WatershedProcessor::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 5430 of file processor.h.

                {
                        return "Does a watershed";
                }

virtual TypeDict EMAN::WatershedProcessor::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 5435 of file processor.h.

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

                {
                        TypeDict d;
                        d.put("xpoints", EMObject::FLOATARRAY,"x coordinates");
                        d.put("ypoints", EMObject::FLOATARRAY,"y coordinates");
                        d.put("zpoints", EMObject::FLOATARRAY,"z coordinates");
                        d.put("minval", EMObject::FLOAT,"min value");
                        return d;
                }

vector< Vec3i > WatershedProcessor::watershed	(	EMData *	mask,
		EMData *	image,
		const float &	threshold,
		const Vec3i &	cordinate,
		const int	mask_value
	)			[private]

Definition at line 1352 of file processor.cpp.

References EMAN::EMData::get_value_at(), EMAN::EMData::get_xsize(), EMAN::EMData::get_ysize(), EMAN::EMData::get_zsize(), and EMAN::EMData::set_value_at().

Referenced by process_inplace().

{
        static vector<Vec3i> two_six_connected;
        if (two_six_connected.size() == 0) {
                for(int i = -1; i <= 1; ++i) {
                        for(int j = -1; j <= 1; ++j) {
                                for(int  k = -1; k <= 1; ++k) {
                                        if ( j != 0 || i != 0 || k != 0) {
                                                two_six_connected.push_back(Vec3i(i,j,k));
                                        }
                                }
                        }
                }
        }

        if  (mask->get_value_at(coordinate[0],coordinate[1],coordinate[2]) != mask_value) throw;

        vector<Vec3i> ret;
        for(vector<Vec3i>::const_iterator it = two_six_connected.begin(); it != two_six_connected.end(); ++it ) {
                Vec3i c = (*it)+coordinate;

                if ( c[0] < 0 || c[0] >= image->get_xsize()) continue;
                if ( c[1] < 0 || c[1] >= image->get_ysize()) continue;
                if ( c[2] < 0 || c[2] >= image->get_zsize()) continue;

        //      cout << image->get_value_at(c[0],c[1],c[2] ) << " " << threshold << endl;
                if( image->get_value_at(c[0],c[1],c[2]) != 0 && (mask->get_value_at(c[0],c[1],c[2]) == 0 )) {
                        //cout << "Added something " << mask_value << endl;
                        mask->set_value_at(c[0],c[1],c[2], (float)mask_value);
                        ret.push_back(c);
                }
        }
        return ret;
}

vector< Vec3i > WatershedProcessor::find_region	(	EMData *	mask,
		const vector< Vec3i > &	coords,
		const int	mask_value,
		vector< Vec3i > &	region
	)			[private]

Definition at line 1314 of file processor.cpp.

References EMAN::EMData::get_value_at(), EMAN::EMData::get_xsize(), EMAN::EMData::get_ysize(), and EMAN::EMData::get_zsize().

Referenced by process_inplace().

{
        static vector<Vec3i> two_six_connected;
        if (two_six_connected.size() == 0) {
                for(int i = -1; i <= 1; ++i) {
                        for(int j = -1; j <= 1; ++j) {
                                for(int  k = -1; k <= 1; ++k) {
                                        if ( j != 0 || i != 0 || k != 0) {
                                                two_six_connected.push_back(Vec3i(i,j,k));
                                        }
                                }
                        }
                }
        }

        vector<Vec3i> ret;
        for(vector<Vec3i>::const_iterator it = two_six_connected.begin(); it != two_six_connected.end(); ++it ) {
                for(vector<Vec3i>::const_iterator it2 = coords.begin(); it2 != coords.end(); ++it2 ) {
                        if  (mask->get_value_at((*it2)[0],(*it2)[1],(*it2)[2]) != mask_value) throw;
                        Vec3i c = (*it)+(*it2);

                        if ( c[0] < 0 || c[0] >= mask->get_xsize()) continue;
                        if ( c[1] < 0 || c[1] >= mask->get_ysize()) continue;
                        if ( c[2] < 0 || c[2] >= mask->get_zsize()) continue;

                        if( mask->get_value_at(c[0],c[1],c[2]) == mask_value ) {
                                if (find(ret.begin(),ret.end(),c) == ret.end()) {
                                        if (find(region.begin(),region.end(),c) == region.end()) {
                                                region.push_back(c);
                                                ret.push_back(c);
                                        }
                                }
                        }
                }
        }
        return ret;
}

---

Member Data Documentation

const string WatershedProcessor::NAME = "watershed" [static]

Definition at line 5445 of file processor.h.

---

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

• processor.h
• processor.cpp