#include <processor.h>
Inheritance diagram for EMAN::TomoTiltEdgeMaskProcessor:
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 TypeDict | get_param_types () const |
Get processor parameter information in a dictionary. | |
virtual string | get_desc () const |
Get the descrition of this specific processor. | |
Static Public Member Functions | |
static Processor * | NEW () |
Static Public Attributes | |
static const string | NAME = "tomo.tiltedgemask" |
Classes | |
class | GaussianFunctoid |
This processors masks out 'mass' in tilted images that is not present in the zero-tilt (0 degrees) image. It does this based on the tilt angle. The tilt angle can be extracted from the image metadata (stored as the euler_alt attribute), or it may be specified explicitly (specifying the angle is the default behavior). The masked out regions at both sides of the image are set to 0 by default, but can also be set to the mean of the nearest non-masked data edge (in the y direction), or similarly the mean of both non-masked data edges on either side of the image. A gaussian fall-off is optional (but off by default).
biedgemean | Mutually exclusive of edgemean. Experimental. Causes the pixels in the masked out areas to take the average value of both the left and right edge pixel strips | |
edgemean | Mutually exclusive of biedgemean. Masked pixels values assume the mean edge pixel value, independently, for both sides of the image | |
angle | The angle that the image is, with respect to the zero tilt image | |
angle_fim | Read fim as 'from image metadata' - this causes the altitude angle stored in by the image object (i.e. as extracted from the header, as currently stored in memory) to be used as the angle. This overrides the angle argument | |
gauss_falloff | Causes the edge masking to have a smooth Gaussian fall-off - this parameter specifies how many pixels the fall-off will proceed over. Default is 0 | |
gauss_sigma | The sigma of the Gaussian function used to smooth the edge fall-off (functional form is exp(-(pixel distance)^2/sigma^2) |
Definition at line 6683 of file processor.h.
|
Get the descrition of this specific processor. This function must be overwritten by a subclass.
Implements EMAN::Processor. Definition at line 6710 of file processor.h. 06711 { 06712 return "Masks the part of the image which is not present in the 0-tilt image. Masked areas can be 0 or set to the edgemean (of the nearest or both edges). Masked areas can also have a Gaussian fall-off to make the appearance smooth."; 06713 }
|
|
Get the processor's name. Each processor is identified by a unique name.
Implements EMAN::Processor. Definition at line 6688 of file processor.h. References NAME. 06689 { 06690 return NAME; 06691 }
|
|
Get processor parameter information in a dictionary. Each parameter has one record in the dictionary. Each record contains its name, data-type, and description.
Reimplemented from EMAN::Processor. Definition at line 6698 of file processor.h. References EMAN::EMObject::BOOL, EMAN::EMObject::FLOAT, EMAN::EMObject::INT, and EMAN::TypeDict::put(). 06699 { 06700 TypeDict d; 06701 d.put("biedgemean", EMObject::BOOL, "Mutually exclusive of edgemean. Experimental. Causes the pixels in the masked out areas to take the average value of both the left and right edge pixel strips"); 06702 d.put("edgemean", EMObject::BOOL, "Mutually exclusive of biedgemean. Masked pixels values assume the mean edge pixel value, independently, for both sides of the image."); 06703 d.put("angle", EMObject::INT, "The angle that the image is, with respect to the zero tilt image"); 06704 d.put("gauss_falloff",EMObject::INT, "Causes the edge masking to have a smooth Gaussian fall-off - this parameter specifies how many pixels the fall-off will proceed over. Default is 0."); 06705 d.put("gauss_sigma",EMObject::FLOAT,"The sigma of the Gaussian function used to smooth the edge fall-off (functional form is exp(-(pixel distance)^2/sigma^2)"); 06706 d.put("angle_fim",EMObject::BOOL,"Read fim as 'from image metadata' - this causes the altitude angle stored in by the image object (i.e. as extracted from the header, as currently stored in memory) to be used as the angle. This overrides the angle argument"); 06707 return d; 06708 }
|
|
Definition at line 6693 of file processor.h. 06694 { 06695 return new TomoTiltEdgeMaskProcessor(); 06696 }
|
|
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.
Implements EMAN::Processor. Definition at line 9322 of file processor.cpp. References EMAN::EMData::get_attr(), EMAN::Transform::get_params(), EMAN::EMData::get_value_at(), EMAN::EMData::get_xsize(), EMAN::EMData::get_ysize(), InvalidParameterException, EMAN::Processor::params, EMAN::EMData::process_inplace(), EMAN::Dict::set_default(), EMAN::EMData::set_value_at(), t, and EMAN::EMData::update(). 09323 { 09324 bool biedgemean = params.set_default("biedgemean", false); 09325 bool edgemean = params.set_default("edgemean", false); 09326 // You can only do one of these - so if someone specifies them both the code complains loudly 09327 if (biedgemean && edgemean) throw InvalidParameterException("The edgemean and biedgemean options are mutually exclusive"); 09328 09329 bool fim = params.set_default("angle_fim", false); 09330 float alt; 09331 if ( fim ) { 09332 Transform* t = (Transform*)image->get_attr("xform.projection"); 09333 Dict d = t->get_params("eman"); 09334 alt = (float) d["alt"]; 09335 if(t) {delete t; t=0;} 09336 } 09337 else alt = params.set_default("angle", 0.0f); 09338 09339 09340 float cosine = cos(alt*M_PI/180.0f); 09341 09342 // Zero the edges 09343 int nx = image->get_xsize(); 09344 int ny = image->get_ysize(); 09345 int x_clip = static_cast<int>( (float) nx * ( 1.0 - cosine ) / 2.0); 09346 09347 float x1_edge_mean = 0.0; 09348 float x2_edge_mean = 0.0; 09349 09350 if ( biedgemean ) 09351 { 09352 float edge_mean = 0.0; 09353 09354 // Accrue the pixel densities on the side strips 09355 for ( int i = 0; i < ny; ++i ) { 09356 edge_mean += image->get_value_at(x_clip, i ); 09357 edge_mean += image->get_value_at(nx - x_clip-1, i ); 09358 } 09359 // Now make it so the mean is stored 09360 edge_mean /= 2*ny; 09361 09362 // Now shift pixel values accordingly 09363 for ( int i = 0; i < ny; ++i ) { 09364 for ( int j = nx-1; j >= nx - x_clip; --j) { 09365 image->set_value_at(j,i,edge_mean); 09366 } 09367 for ( int j = 0; j < x_clip; ++j) { 09368 image->set_value_at(j,i,edge_mean); 09369 } 09370 } 09371 x1_edge_mean = edge_mean; 09372 x2_edge_mean = edge_mean; 09373 } 09374 else if (edgemean) 09375 { 09376 for ( int i = 0; i < ny; ++i ) { 09377 x1_edge_mean += image->get_value_at(x_clip, i ); 09378 x2_edge_mean += image->get_value_at(nx - x_clip-1, i ); 09379 } 09380 x1_edge_mean /= ny; 09381 x2_edge_mean /= ny; 09382 09383 for ( int i = 0; i < ny; ++i ) { 09384 for ( int j = 0; j < x_clip; ++j) { 09385 image->set_value_at(j,i,x1_edge_mean); 09386 } 09387 for ( int j = nx-1; j >= nx - x_clip; --j) { 09388 image->set_value_at(j,i,x2_edge_mean); 09389 } 09390 } 09391 } 09392 else 09393 { 09394 // The edges are just zeroed - 09395 Dict zero_dict; 09396 zero_dict["x0"] = x_clip; 09397 zero_dict["x1"] = x_clip; 09398 zero_dict["y0"] = 0; 09399 zero_dict["y1"] = 0; 09400 image->process_inplace( "mask.zeroedge2d", zero_dict ); 09401 } 09402 09403 int gauss_rad = params.set_default("gauss_falloff", 0); 09404 if ( gauss_rad != 0) 09405 { 09406 // If the gaussian falloff distance is greater than x_clip, it will technically 09407 // go beyond the image boundaries. Thus we clamp gauss_rad so this cannot happen. 09408 // Therefore, there is potential here for (benevolent) unexpected behavior. 09409 if ( gauss_rad > x_clip ) gauss_rad = x_clip; 09410 09411 float gauss_sigma = params.set_default("gauss_sigma", 3.0f); 09412 if ( gauss_sigma < 0 ) throw InvalidParameterException("Error - you must specify a positive, non-zero gauss_sigma"); 09413 float sigma = (float) gauss_rad/gauss_sigma; 09414 09415 GaussianFunctoid gf(sigma); 09416 09417 for ( int i = 0; i < ny; ++i ) { 09418 09419 float left_value = image->get_value_at(x_clip, i ); 09420 float scale1 = left_value-x1_edge_mean; 09421 09422 float right_value = image->get_value_at(nx - x_clip - 1, i ); 09423 float scale2 = right_value-x2_edge_mean; 09424 09425 for ( int j = 1; j < gauss_rad; ++j ) 09426 { 09427 image->set_value_at(x_clip-j, i, scale1*gf((float)j)+x1_edge_mean ); 09428 image->set_value_at(nx - x_clip + j-1, i, scale2*gf((float)j)+x2_edge_mean); 09429 } 09430 } 09431 } 09432 09433 image->update(); 09434 }
|
|
Definition at line 6715 of file processor.h. Referenced by get_name(). |