#include <processor.h>
Inheritance diagram for EMAN::BooleanShrinkProcessor:
Protected Member Functions | |
template<class LogicOp> | |
EMData * | process (const EMData *const image, Dict ¶ms) |
Boolean shrink an image, returning the processed image. | |
template<class LogicOp> | |
void | process_inplace (EMData *image, Dict ¶ms) |
Boolean shrink an image inplace. |
Both of these instances are written at compile time using templates.
Definition at line 3219 of file processor.h.
|
Boolean shrink an image, returning the processed image.
Definition at line 2359 of file processor.cpp. References EMAN::EMData::copy(), EMAN::EMData::get_value_at(), EMAN::EMData::get_xsize(), EMAN::EMData::get_ysize(), EMAN::EMData::get_zsize(), ImageFormatException, InvalidValueException, EMAN::EMData::is_complex(), NullPointerException, nx, ny, EMAN::Dict::set_default(), EMAN::EMData::set_size(), EMAN::EMData::set_value_at(), EMAN::EMData::update(), x, and y. 02360 { 02361 // The basic idea of this code is to iterate through each pixel in the output image 02362 // determining its value by investigation a region of the input image 02363 02364 if (!image) throw NullPointerException("Attempt to max shrink a null image"); 02365 02366 if (image->is_complex() ) throw ImageFormatException("Can not max shrink a complex image"); 02367 02368 02369 int shrink = params.set_default("n",2); 02370 int search = params.set_default("search",2); 02371 02372 if ( shrink < 0 ) throw InvalidValueException(shrink, "Can not shrink by a value less than 0"); 02373 02374 02375 int nz = image->get_zsize(); 02376 int ny = image->get_ysize(); 02377 int nx = image->get_xsize(); 02378 02379 if (nx == 1 && ny == 1 && nz == 1 ) return image->copy(); 02380 02381 LogicOp op; 02382 EMData* return_image = new EMData(); 02383 02384 int shrinkx = shrink; 02385 int shrinky = shrink; 02386 int shrinkz = shrink; 02387 02388 int searchx = search; 02389 int searchy = search; 02390 int searchz = search; 02391 02392 // Clamping the shrink values to the dimension lengths 02393 // ensures that the return image has non zero dimensions 02394 if ( shrinkx > nx ) shrinkx = nx; 02395 if ( shrinky > ny ) shrinky = ny; 02396 if ( shrinkz > nz ) shrinkz = nz; 02397 02398 if ( nz == 1 && ny == 1 ) 02399 { 02400 return_image->set_size(nx/shrinkx); 02401 for(int i = 0; i < nx/shrinkx; ++i) 02402 { 02403 float tmp = op.get_start_val(); 02404 for(int s=0; s < searchx; ++s) 02405 { 02406 int idx = shrinkx*i+s; 02407 // Don't ask for memory beyond limits 02408 if ( idx > nx ) break; 02409 else 02410 { 02411 float val = image->get_value_at(idx); 02412 if ( op( val,tmp) ) tmp = val; 02413 } 02414 } 02415 return_image->set_value_at(i,tmp); 02416 } 02417 } 02418 else if ( nz == 1 ) 02419 { 02420 int ty = ny/shrinky; 02421 int tx = nx/shrinkx; 02422 return_image->set_size(tx,ty); 02423 for(int y = 0; y < ty; ++y) { 02424 for(int x = 0; x < tx; ++x) { 02425 float tmp = op.get_start_val(); 02426 for(int sy=0; sy < searchy; ++sy) { 02427 int yidx = shrinky*y+sy; 02428 if ( yidx >= ny) break; 02429 for(int sx=0; sx < searchx; ++sx) { 02430 int xidx = shrinkx*x+sx; 02431 if ( xidx >= nx) break; 02432 02433 float val = image->get_value_at(xidx,yidx); 02434 if ( op( val,tmp) ) tmp = val; 02435 } 02436 } 02437 return_image->set_value_at(x,y,tmp); 02438 } 02439 } 02440 } 02441 else 02442 { 02443 int tz = nz/shrinkz; 02444 int ty = ny/shrinky; 02445 int tx = nx/shrinkx; 02446 02447 return_image->set_size(tx,ty,tz); 02448 for(int z = 0; z < tz; ++z) { 02449 for(int y = 0; y < ty; ++y) { 02450 for(int x = 0; x < tx; ++x) { 02451 float tmp = op.get_start_val(); 02452 02453 for(int sz=0; sz < searchz; ++sz) { 02454 int zidx = shrinkz*z+sz; 02455 if ( zidx >= nz) break; 02456 02457 for(int sy=0; sy < searchy; ++sy) { 02458 int yidx = shrinky*y+sy; 02459 if ( yidx >= ny) break; 02460 02461 for(int sx=0; sx < searchx; ++sx) { 02462 int xidx = shrinkx*x+sx; 02463 if ( xidx >= nx) break; 02464 float val = image->get_value_at(xidx,yidx,zidx); 02465 if ( op( val,tmp) ) tmp = val; 02466 } 02467 } 02468 } 02469 return_image->set_value_at(x,y,z,tmp); 02470 } 02471 } 02472 } 02473 } 02474 return_image->update(); 02475 02476 return return_image; 02477 }
|
|
Boolean shrink an image inplace.
Definition at line 2480 of file processor.cpp. References EMAN::EMData::get_value_at(), EMAN::EMData::get_xsize(), EMAN::EMData::get_ysize(), EMAN::EMData::get_zsize(), ImageFormatException, InvalidValueException, EMAN::EMData::is_complex(), NullPointerException, nx, ny, EMAN::Dict::set_default(), EMAN::EMData::set_size(), EMAN::EMData::set_value_at(), EMAN::EMData::update(), x, and y. 02481 { 02482 // The basic idea of this code is to iterate through each pixel in the output image 02483 // determining its value by investigation a region of the input image 02484 if (!image) throw NullPointerException("Attempt to max shrink a null image"); 02485 02486 if (image->is_complex() ) throw ImageFormatException("Can not max shrink a complex image"); 02487 02488 02489 int shrink = params.set_default("shrink",2); 02490 int search = params.set_default("search",2); 02491 02492 if ( shrink < 0 ) throw InvalidValueException(shrink, "Can not shrink by a value less than 0"); 02493 02494 02495 int nz = image->get_zsize(); 02496 int ny = image->get_ysize(); 02497 int nx = image->get_xsize(); 02498 02499 LogicOp op; 02500 02501 int shrinkx = shrink; 02502 int shrinky = shrink; 02503 int shrinkz = shrink; 02504 02505 int searchx = search; 02506 int searchy = search; 02507 int searchz = search; 02508 02509 // Clamping the shrink values to the dimension lengths 02510 // ensures that the return image has non zero dimensions 02511 if ( shrinkx > nx ) shrinkx = nx; 02512 if ( shrinky > ny ) shrinkx = ny; 02513 if ( shrinkz > nz ) shrinkx = nz; 02514 02515 if (nx == 1 && ny == 1 && nz == 1 ) return; 02516 02517 if ( nz == 1 && ny == 1 ) 02518 { 02519 for(int i = 0; i < nx/shrink; ++i) 02520 { 02521 float tmp = op.get_start_val(); 02522 for(int s=0; s < searchx; ++s) 02523 { 02524 int idx = shrinkx*i+s; 02525 if ( idx > nx ) break; 02526 else 02527 { 02528 float val = image->get_value_at(idx); 02529 if ( op( val,tmp) ) tmp = val; 02530 } 02531 } 02532 image->set_value_at(i,tmp); 02533 } 02534 02535 image->set_size(nx/shrinkx); 02536 } 02537 else if ( nz == 1 ) 02538 { 02539 int ty = ny/shrinky; 02540 int tx = nx/shrinkx; 02541 for(int y = 0; y < ty; ++y) { 02542 for(int x = 0; x < tx; ++x) { 02543 float tmp = op.get_start_val(); 02544 for(int sy=0; sy < searchy; ++sy) { 02545 int yidx = shrinky*y+sy; 02546 if ( yidx >= ny) break; 02547 for(int sx=0; sx < searchx; ++sx) { 02548 int xidx = shrinkx*x+sx; 02549 if ( xidx >= nx) break; 02550 02551 float val = image->get_value_at(xidx,yidx); 02552 if ( op( val,tmp) ) tmp = val; 02553 } 02554 } 02555 (*image)(x+tx*y) = tmp; 02556 } 02557 } 02558 image->set_size(tx,ty); 02559 } 02560 else 02561 { 02562 int tnxy = nx/shrinkx*ny/shrinky; 02563 int tz = nz/shrinkz; 02564 int ty = ny/shrinky; 02565 int tx = nx/shrinkx; 02566 02567 for(int z = 0; z < tz; ++z) { 02568 for(int y = 0; y < ty; ++y) { 02569 for(int x = 0; x < tx; ++x) { 02570 float tmp = op.get_start_val(); 02571 for(int sz=0; sz < searchz; ++sz) { 02572 int zidx = shrinkz*z+sz; 02573 if ( zidx >= nz) break; 02574 for(int sy=0; sy < searchy; ++sy) { 02575 int yidx = shrinky*y+sy; 02576 if ( yidx >= ny) break; 02577 for(int sx=0; sx < shrinkx; ++sx) { 02578 int xidx = shrinkx*x+sx; 02579 if ( xidx >= nx) break; 02580 02581 float val = image->get_value_at(xidx,yidx,zidx); 02582 if ( op( val,tmp) ) tmp = val; 02583 } 02584 } 02585 } 02586 (*image)(x+tx*y+tnxy*z) = tmp; 02587 } 02588 } 02589 } 02590 image->set_size(tx,ty,tz); 02591 } 02592 image->update(); 02593 }
|