BooleanShrinkProcessor encapsulates code common to MaxShrinkProcessor and MinShrinkProcessor - the processors use more or less identical code, the main difference being the logical operator. More...

#include <processor.h>

Inheritance diagram for EMAN::BooleanShrinkProcessor:

[legend]

Protected Member Functions
template<class LogicOp >
EMData *	process (const EMData *const image, Dict &params)
	Boolean shrink an image, returning the processed image. More...

template<class LogicOp >
void	process_inplace (EMData *image, Dict &params)
	Boolean shrink an image inplace. More...

Detailed Description

BooleanShrinkProcessor encapsulates code common to MaxShrinkProcessor and MinShrinkProcessor - the processors use more or less identical code, the main difference being the logical operator.

Both of these instances are written at compile time using templates.

Definition at line 4844 of file processor.h.

Member Function Documentation

◆ process()

template<class LogicOp >

EMData * BooleanShrinkProcessor::process	(	const EMData *const	image,
		Dict &	params
	)

protected

Boolean shrink an image, returning the processed image.

Parameters

image	the image to operate on
params	parameter dictionary

Exceptions

ImageFormatException	if the image is complex
NullPointerException	if the image pointer is null

Returns: the image that results from the operation

Definition at line 3344 of file processor.cpp.

{
        // The basic idea of this code is to iterate through each pixel in the output image
        // determining its value by investigation a region of the input image
 
        if (!image) throw NullPointerException("Attempt to max shrink a null image");
 
        if (image->is_complex() ) throw ImageFormatException("Can not max shrink a complex image");
 
 
        int shrink = params.set_default("n",2);
        int search = params.set_default("search",2);
 
        if ( shrink < 0 ) throw InvalidValueException(shrink, "Can not shrink by a value less than 0");
 
 
        int nz = image->get_zsize();
        int ny = image->get_ysize();
        int nx = image->get_xsize();
 
        if (nx == 1 && ny == 1 && nz == 1 ) return image->copy();
 
        LogicOp op;
        EMData* return_image = new EMData();
 
        int shrinkx = shrink;
        int shrinky = shrink;
        int shrinkz = shrink;
 
        int searchx = search;
        int searchy = search;
        int searchz = search;
 
        // Clamping the shrink values to the dimension lengths
        // ensures that the return image has non zero dimensions
        if ( shrinkx > nx ) shrinkx = nx;
        if ( shrinky > ny ) shrinky = ny;
        if ( shrinkz > nz ) shrinkz = nz;
 
        if ( nz == 1 && ny == 1 )
        {
                return_image->set_size(nx/shrinkx);
                for(int i = 0; i < nx/shrinkx; ++i)
                {
                        float tmp = op.get_start_val();
                        for(int s=0; s < searchx; ++s)
                        {
                                int idx = shrinkx*i+s;
                                // Don't ask for memory beyond limits
                                if ( idx > nx ) break;
                                else
                                {
                                        float val = image->get_value_at(idx);
                                        if ( op( val,tmp) ) tmp = val;
                                }
                        }
                        return_image->set_value_at(i,tmp);
                }
        }
        else if ( nz == 1 )
        {
                int ty = ny/shrinky;
                int tx = nx/shrinkx;
                return_image->set_size(tx,ty);
                for(int y = 0; y < ty; ++y) {
                        for(int x = 0; x < tx; ++x) {
                                float tmp = op.get_start_val();
                                for(int sy=0; sy < searchy; ++sy) {
                                        int yidx = shrinky*y+sy;
                                        if ( yidx >= ny) break;
                                        for(int sx=0; sx < searchx; ++sx) {
                                                int xidx = shrinkx*x+sx;
                                                if ( xidx >= nx) break;
 
                                                float val = image->get_value_at(xidx,yidx);
                                                if ( op( val,tmp) ) tmp = val;
                                        }
                                }
                                return_image->set_value_at(x,y,tmp);
                        }
                }
        }
        else
        {
                int tz = nz/shrinkz;
                int ty = ny/shrinky;
                int tx = nx/shrinkx;
 
                return_image->set_size(tx,ty,tz);
                for(int z = 0; z < tz; ++z) {
                        for(int y = 0; y < ty; ++y) {
                                for(int x = 0; x < tx; ++x) {
                                        float tmp = op.get_start_val();
 
                                        for(int sz=0; sz < searchz; ++sz) {
                                                int zidx = shrinkz*z+sz;
                                                if ( zidx >= nz) break;
 
                                                for(int sy=0; sy < searchy; ++sy) {
                                                        int yidx = shrinky*y+sy;
                                                        if ( yidx >= ny) break;
 
                                                        for(int sx=0; sx < searchx; ++sx) {
                                                                int xidx = shrinkx*x+sx;
                                                                if ( xidx >= nx) break;
                                                                float val = image->get_value_at(xidx,yidx,zidx);
                                                                if ( op( val,tmp) ) tmp = val;
                                                        }
                                                }
                                        }
                                        return_image->set_value_at(x,y,z,tmp);
                                }
                        }
                }
        }
        return_image->update();
 
        return return_image;
}

References ImageFormatException, InvalidValueException, NullPointerException, EMAN::Dict::set_default(), x, and y.

◆ process_inplace()

template<class LogicOp >

void BooleanShrinkProcessor::process_inplace	(	EMData *	image,
		Dict &	params
	)

protected

Boolean shrink an image inplace.