#include <classify_extract_features.h>

Inheritance diagram for ProgExtractFeatures:

Collaboration diagram for ProgExtractFeatures:

Public Member Functions
	ProgExtractFeatures ()=default

	ProgExtractFeatures (const ProgExtractFeatures &)=delete

	ProgExtractFeatures (const ProgExtractFeatures &&)=delete

	~ProgExtractFeatures ()

ProgExtractFeatures &	operator= (const ProgExtractFeatures &)=delete

ProgExtractFeatures &	operator= (const ProgExtractFeatures &&)=delete

void	readParams ()
	Read argument. More...

void	show ()
	Show. More...

void	defineParams ()
	Define parameters. More...

int	facs (int n)
	Function for returning factorial up to n=4. More...

void	extractEntropy (const MultidimArray< double > &I, MultidimArray< double > &Imasked, std::vector< double > &fv)
	Extracting entropy features. More...

void	extractGranulo (const MultidimArray< double > &I, std::vector< double > &fv)
	Extracting granulometry features. More...

void	extractHistDist (const MultidimArray< double > &I, std::vector< double > &fv)
	Extracting histogram distances. More...

void	extractLBP (const MultidimArray< double > &I, std::vector< double > &fv)

void	extractRamp (const MultidimArray< double > &I, std::vector< double > &fv)
	Gray ramp coefficients. More...

void	extractVariance (const MultidimArray< double > &I, std::vector< double > &fv)
	Extracting variance features. More...

void	extractZernike (const MultidimArray< double > &I, std::vector< double > &fv)

void	run ()
	Main routine. More...

Public Member Functions inherited from XmippProgram
const char *	getParam (const char *param, int arg=0)

const char *	getParam (const char param, const char subparam, int arg=0)

int	getIntParam (const char *param, int arg=0)

int	getIntParam (const char param, const char subparam, int arg=0)

double	getDoubleParam (const char *param, int arg=0)

double	getDoubleParam (const char param, const char subparam, int arg=0)

float	getFloatParam (const char *param, int arg=0)

float	getFloatParam (const char param, const char subparam, int arg=0)

void	getListParam (const char *param, StringVector &list)

int	getCountParam (const char *param)

bool	checkParam (const char *param)

bool	existsParam (const char *param)

void	addParamsLine (const String &line)

void	addParamsLine (const char *line)

ParamDef *	getParamDef (const char *param) const

virtual void	quit (int exit_code=0) const

virtual int	tryRun ()

void	initProgress (size_t total, size_t stepBin=60)

void	setProgress (size_t value=0)

void	endProgress ()

void	processDefaultComment (const char param, const char left)

void	setDefaultComment (const char param, const char comment)

virtual void	initComments ()

void	setProgramName (const char *name)

void	addUsageLine (const char *line, bool verbatim=false)

void	clearUsage ()

void	addExampleLine (const char *example, bool verbatim=true)

void	addSeeAlsoLine (const char *seeAlso)

void	addKeywords (const char *keywords)

const char *	name () const

virtual void	usage (int verb=0) const

virtual void	usage (const String &param, int verb=2)

int	version () const

virtual void	show () const

virtual void	read (int argc, const char **argv, bool reportErrors=true)

virtual void	read (int argc, char **argv, bool reportErrors=true)

void	read (const String &argumentsLine)

	XmippProgram ()

	XmippProgram (int argc, const char **argv)

virtual	~XmippProgram ()

Public Attributes
FileName	fnSel

FileName	fnOut

bool	applyDenoising

bool	useEntropy

bool	useGranulo

bool	useHistDist

bool	useLBP

bool	useRamp

bool	useVariance

bool	useZernike

MultidimArray< int >	masks [7]

MultidimArray< int >	rampMask

FitPoint *	fitPoints =nullptr

int	NmaskPoints

Public Attributes inherited from XmippProgram
bool	doRun

bool	runWithoutArgs

int	verbose
	Verbosity level. More...

int	debug

Additional Inherited Members
Protected Member Functions inherited from XmippProgram
void	defineCommons ()

Protected Attributes inherited from XmippProgram
int	errorCode

ProgramDef *	progDef
	Program definition and arguments parser. More...

std::map< String, CommentList >	defaultComments

int	argc
	Original command line arguments. More...

const char **	argv

Detailed Description

Definition at line 37 of file classify_extract_features.h.

Constructor & Destructor Documentation

◆ ProgExtractFeatures() [1/3]

ProgExtractFeatures::ProgExtractFeatures ( )

default

◆ ProgExtractFeatures() [2/3]

ProgExtractFeatures::ProgExtractFeatures ( const ProgExtractFeatures & )

delete

◆ ProgExtractFeatures() [3/3]

ProgExtractFeatures::ProgExtractFeatures ( const ProgExtractFeatures && )

delete

◆ ~ProgExtractFeatures()

ProgExtractFeatures::~ProgExtractFeatures ( )

Definition at line 33 of file classify_extract_features.cpp.

 {
     if (fitPoints!=nullptr)
         delete []fitPoints;
 }

Member Function Documentation

◆ defineParams()

void ProgExtractFeatures::defineParams ( )

virtual

Define parameters.

Reimplemented from XmippProgram.

Definition at line 74 of file classify_extract_features.cpp.

 {
     addUsageLine("Clusters a set of images");
     addParamsLine("  -i <selfile>             : Images to be clustered");
     addParamsLine("  [-o <selfile=\"\">]      : Output selfile");
     addParamsLine("  [--applyDenoising]       : Turn on denoising");
     addParamsLine("  [--entropy]              : Extract entropy features");
     addParamsLine("  [--granulo]              : Extract granulo features");
     addParamsLine("  [--histdist]             : Extract histogram distances");
     addParamsLine("  [--lbp]                  : Extract LBP features");
     addParamsLine("  [--ramp]                 : Extract Ramp coefficients");
     addParamsLine("  [--variance]             : Extract variance features");
     addParamsLine("  [--zernike]              : Extract Zernike moments");
 }

◆ extractEntropy()

void ProgExtractFeatures::extractEntropy	(	const MultidimArray< double > &	I,
		MultidimArray< double > &	Imasked,
		std::vector< double > &	fv
	)

Extracting entropy features.

Definition at line 98 of file classify_extract_features.cpp.

 {
     int hist[256] = {};
     int val;
 
     // entropy of entire image
     double m, M;
     I.computeDoubleMinMax(m,M);
     FOR_ALL_DIRECT_ELEMENTS_IN_MULTIDIMARRAY(I)
     {
         val = floor(((DIRECT_MULTIDIM_ELEM(I, n) - m) * 255.0) / (M - m));
         hist[val]++;
     }
 
     double entropy = 0;
     for (int i = 0; i < 256; i++)
         entropy += std::max(hist[i], 1) * log2((std::max(hist[i], 1)));
 
     fv.push_back(-1*entropy);
 
     // preparing masks for feature extraction, will be performed only once
     if (XSIZE(masks[0]) < 1)
     {
         for (int i = 0; i < (sizeof(masks)/sizeof(*masks)); i++)
         {
             masks[i].resize(I);
             masks[i].setXmippOrigin();
         }
 
         int wave_size = XSIZE(I) / 2;
         int wave_size_step = XSIZE(I) / 32;
 
         // simple inner-circle regions without negative values
 //        for (int i=2; i<(sizeof(masks)/sizeof(*masks)); i++)
 //        {
 //            BinaryCircularMask(masks[0], wave_size);
 //            BinaryCircularMask(masks[1], wave_size - wave_size_step);
 //
 //            // if we want overlapping regions (rings)
 //            // BinaryCircularMask(masks[1], wave_size - 2*wave_size_step);
 //
 //            FOR_ALL_DIRECT_ELEMENTS_IN_MULTIDIMARRAY(masks[0])
 //                DIRECT_MULTIDIM_ELEM(masks[i],n) = DIRECT_MULTIDIM_ELEM(masks[0],n) -
 //                                                   DIRECT_MULTIDIM_ELEM(masks[1],n);
 //
 //            wave_size -= wave_size_step;
 //        }
 
         for (int i = 2; i < (sizeof(masks)/sizeof(*masks)); i++)
         {
             BinaryCircularMask(masks[0], wave_size);
             BinaryCircularMask(masks[1], wave_size - wave_size_step);
 
             FOR_ALL_DIRECT_ELEMENTS_IN_MULTIDIMARRAY(masks[0])
                 DIRECT_MULTIDIM_ELEM(masks[i],n) = 2*DIRECT_MULTIDIM_ELEM(masks[1],n) -
                                                    DIRECT_MULTIDIM_ELEM(masks[0],n);
 
             BinaryCircularMask(masks[1], wave_size - 2*wave_size_step);
             FOR_ALL_DIRECT_ELEMENTS_IN_MULTIDIMARRAY(masks[0])
                 DIRECT_MULTIDIM_ELEM(masks[i],n) = DIRECT_MULTIDIM_ELEM(masks[i],n) -
                                                    DIRECT_MULTIDIM_ELEM(masks[1],n);
 
 
             wave_size -= wave_size_step;     // overlapping regions (rings)
             //wave_size -= 2*wave_size_step;   // non-overlapping regions (rings)
         }
     }
 
     // extracting entropy from unmasked regions
     for (int i = 2; i < (sizeof(masks)/sizeof(*masks)); i++)
     {
         apply_binary_mask(masks[i], I, Imasked);
         int hist[256] = {};
         int idx;
         Imasked.computeDoubleMinMax(m,M);
         FOR_ALL_DIRECT_ELEMENTS_IN_MULTIDIMARRAY(Imasked)
         {
             idx = floor(((DIRECT_MULTIDIM_ELEM(Imasked, n) - m) * 255.0) / (M-m));
             hist[idx]++;
         }
 
         double entropy = 0;
         for (int i = 0; i < 256; i++)
             entropy += std::max(hist[i], 1) * log2(std::max(hist[i], 1));
 
         fv.push_back(-1*entropy);
     }
 }

◆ extractGranulo()

void ProgExtractFeatures::extractGranulo	(	const MultidimArray< double > &	I,
		std::vector< double > &	fv
	)

Extracting granulometry features.

Definition at line 190 of file classify_extract_features.cpp.

 {
     Image<double> G;
     G().resizeNoCopy(I);
     double m, M;
     I.computeDoubleMinMax(m, M);
 
     if (XSIZE(I) < 15 || YSIZE(I) < 15)
     {
         std::cerr << "ERROR: Input image must be at least 15x15px"
                   << "to extract granulo features!\n";
         exit(1);
     }
 
     for (int N = 1; N < 7; N++)
     {
         // creating circular structuring element
         int size = N*2 + 1;
         bool struct_elem[size][size];
         for (int y = 0; y < size; y++)
         {
             for (int x = 0; x < size; x++)
                 struct_elem[x][y] = ((x-N)*(x-N) + (y-N)*(y-N)) <= N*N;
         }
 
         // morphological erosion
         double sum = 0.0;
         for (int y = 0; y < YSIZE(I); y++)
         {
             for (int x = 0; x < XSIZE(I); x++)
             {
                 double struct_min = M;
 
                 for (int yy = y-N; yy <= y+N; yy++)
                 {
                     if (yy < 0 || yy >= YSIZE(I)) continue;
 
                     for (int xx = x-N; xx <= x+N; xx++)
                     {
                         if (xx < 0 || xx >= XSIZE(I)) continue;
 
                         if (struct_elem[xx+N-x][yy+N-y] &&
                             DIRECT_A2D_ELEM(I, yy, xx) < struct_min)
                             struct_min = DIRECT_A2D_ELEM(I, yy, xx);
                     }
                 }
                 DIRECT_A2D_ELEM(G(), y, x) = struct_min;
             }
         }
 
         // morphological dilation (dilation after erosion = opening)
         for (int y = 0; y < YSIZE(I); y++)
         {
             for (int x = 0; x < XSIZE(I); x++)
             {
                 double struct_max = m;
 
                 for (int yy = y-N; yy <= y+N; yy++)
                 {
                     if (yy < 0 || yy >= YSIZE(I)) continue;
 
                     for (int xx = x-N; xx <= x+N; xx++)
                     {
                         if (xx < 0 || xx >= XSIZE(I)) continue;
 
                         if (struct_elem[xx+N-x][yy+N-y] &&
                             DIRECT_A2D_ELEM(G(), yy, xx) > struct_max)
                             struct_max = DIRECT_A2D_ELEM(G(), yy, xx);
                     }
                 }
                 sum += struct_max;
             }
         }
         fv.push_back(sum);
     }
 }

◆ extractHistDist()

void ProgExtractFeatures::extractHistDist	(	const MultidimArray< double > &	I,
		std::vector< double > &	fv
	)

Extracting histogram distances.

Definition at line 269 of file classify_extract_features.cpp.

 {
     MultidimArray<double> Ipart;
     Ipart.resize(XSIZE(I)/3, YSIZE(I)/3);
     for (int yy = 1; yy <= 3; yy++)
     {
         int y_max = YSIZE(I) / 3 * yy;
         int y_min = YSIZE(I) / 3 * (yy-1);
         for (int xx = 1; xx <= 3; xx++)
         {
             int x_max = XSIZE(I) / 3 * xx;
             int x_min = XSIZE(I) / 3 * (xx-1);
             int ypart = 0;
             for (int y = y_min; y < y_max; y++)
             {
                 int xpart = 0;
                 for (int x = x_min; x < x_max; x++)
                 {
                     DIRECT_A2D_ELEM(Ipart, ypart, xpart) =
                         DIRECT_A2D_ELEM(I, y, x);
                     xpart++;
                 }
                 ypart++;
             }
 
             int count = XSIZE(Ipart) + YSIZE(Ipart);
             int hist[256] = {};
             int low_thresh, high_thresh;
             int low_thresh_cnt = 0, high_thresh_cnt = 0;
             typedef std::pair<int, int> pairs;
             std::set<pairs> low_inten_pts, high_inten_pts;
 
             int temp;
             double m, M;
             Ipart.computeDoubleMinMax(m, M);
             FOR_ALL_DIRECT_ELEMENTS_IN_MULTIDIMARRAY(Ipart)
             {
                 temp = floor(((DIRECT_MULTIDIM_ELEM(Ipart, n)- m)*255.0) / (M-m));
                 hist[temp]++;
                 DIRECT_MULTIDIM_ELEM(Ipart, n) = temp;
             }
 
             for (low_thresh = 0; low_thresh_cnt < count; low_thresh++)
                 low_thresh_cnt += hist[low_thresh];
             for (high_thresh = 255; high_thresh_cnt < count; high_thresh--)
                 high_thresh_cnt += hist[high_thresh];
 
             FOR_ALL_DIRECT_ELEMENTS_IN_ARRAY2D(Ipart)
             {
                 if (DIRECT_A2D_ELEM(Ipart, i, j) < low_thresh)
                     low_inten_pts.insert(std::make_pair(i, j));
                 else if (DIRECT_A2D_ELEM(Ipart, i, j) > high_thresh)
                     high_inten_pts.insert(std::make_pair(i, j));
             }
 
             double dist_high = 0.0, dist_low = 0.0;
             int comparisons = 0;
 
             for (std::set<pairs>:: iterator it1 = high_inten_pts.begin();
                  it1 != --high_inten_pts.end(); ++it1)
             {
                 pairs p1 = *it1;
                 for (std::set<pairs>::iterator it2 = ++it1;
                      it2 != high_inten_pts.end(); ++it2)
                 {
                     pairs p2 = *it2;
                     dist_high += sqrt((p1.first - p2.first) * (p1.first - p2.first) +
                                       (p1.second - p2.second) * (p1.second - p2.second));
                     comparisons++;
                 }
                 --it1;
             }
             fv.push_back(dist_high / comparisons);
 
             comparisons = 0;
             for (std::set<pairs>:: iterator it1 = low_inten_pts.begin();
                  it1 != --low_inten_pts.end(); ++it1)
             {
                 pairs p1 = *it1;
                 for (std::set<pairs>::iterator it2 = ++it1;
                      it2 != low_inten_pts.end(); ++it2)
                 {
                     pairs p2 = *it2;
                     dist_low += sqrt((p1.first - p2.first) * (p1.first - p2.first) +
                                      (p1.second - p2.second) * (p1.second - p2.second));
                     comparisons++;
                 }
                 --it1;
             }
             fv.push_back(dist_low / comparisons);
         }
     }
 }

◆ extractLBP()

void ProgExtractFeatures::extractLBP	(	const MultidimArray< double > &	I,
		std::vector< double > &	fv
	)

Extracting LBP features See method at Ojala, Timo, Matti Pietikainen, and Topi Maenpaa. "Multiresolution gray-scale and rotation invariant texture classification with local binary patterns." IEEE Transactions on Pattern Analysis and Machine Intelligence 24.7 (2002): 971-987.

Definition at line 365 of file classify_extract_features.cpp.

 {
     std::vector<double> min_idxs, min_idxs_sort;
 
     unsigned char code;
     double center;
     int lbp_hist[256] = {};
 
     for (int i = 0; i < 256; i++)
     {
         code = i;
         auto code_min = (int) code;
         for (int ii = 0; ii < 7; ii++)
         {
             unsigned char c = code & 1;
             code >>= 1;
             code |= (c << 7);
             if ((int) code < code_min)
                 code_min = (int) code;
         }
         min_idxs.push_back(code_min);
     }
     min_idxs_sort = min_idxs;
     std::sort(min_idxs_sort.begin(), min_idxs_sort.end());
     auto last=std::unique(min_idxs_sort.begin(), min_idxs_sort.end());
     min_idxs_sort.erase(last,min_idxs_sort.end());
 
     for (int y = 1; y < (YSIZE(I)-1); y++)
     {
         for (int x = 1; x < (XSIZE(I)-1); x++)
         {
             code = 0;
             center = DIRECT_A2D_ELEM(I,y,x);
             code |= (DIRECT_A2D_ELEM(I,y-1,x-1) > center) << 7;
             code |= (DIRECT_A2D_ELEM(I,y-1,x  ) > center) << 6;
             code |= (DIRECT_A2D_ELEM(I,y-1,x+1) > center) << 5;
             code |= (DIRECT_A2D_ELEM(I,y,  x+1) > center) << 4;
             code |= (DIRECT_A2D_ELEM(I,y+1,x+1) > center) << 3;
             code |= (DIRECT_A2D_ELEM(I,y+1,x  ) > center) << 2;
             code |= (DIRECT_A2D_ELEM(I,y+1,x-1) > center) << 1;
             code |= (DIRECT_A2D_ELEM(I,y  ,x-1) > center) << 0;
             int idx = min_idxs[(int) code];
             lbp_hist[idx]++;
         }
     }
 
     for (int i = 0; i < 36; i++)
     {
         int idx = min_idxs_sort[i];
         fv.push_back(lbp_hist[idx]);
     }
 }

◆ extractRamp()

void ProgExtractFeatures::extractRamp	(	const MultidimArray< double > &	I,
		std::vector< double > &	fv
	)

Gray ramp coefficients.

Definition at line 419 of file classify_extract_features.cpp.

 {
     if (XSIZE(rampMask)==0)
     {
         rampMask.resize(I);
         rampMask.setXmippOrigin();
         BinaryCircularMask(rampMask,XSIZE(I)/2,OUTSIDE_MASK);
         NmaskPoints=rampMask.sum();
         fitPoints=new FitPoint[NmaskPoints];
     }
     size_t idx=0;
     FOR_ALL_ELEMENTS_IN_ARRAY2D(I)
     {
         if (A2D_ELEM(rampMask, i, j))
         {
             FitPoint &p=fitPoints[idx++];
             p.x = j;
             p.y = i;
             p.z = A2D_ELEM(I, i, j);
             p.w = 1.;
         }
     }
 
     double pA, pB, pC;
     least_squares_plane_fit(fitPoints, NmaskPoints, pA, pB, pC);
     fv.push_back(pA);
     fv.push_back(pB);
     fv.push_back(pC);
 }

◆ extractVariance()

void ProgExtractFeatures::extractVariance	(	const MultidimArray< double > &	I,
		std::vector< double > &	fv
	)

Extracting variance features.

Definition at line 451 of file classify_extract_features.cpp.

 {
     double var_i_sum = 0.0;
     double var_o_sum = 0.0;
     for (int yy = 1; yy <= 4; yy++)
     {
         int y_max = YSIZE(I) / 4 * yy;
         int y_min = YSIZE(I) / 4 * (yy-1);
         for (int xx = 1; xx <= 4; xx++)
         {
             int x_max = XSIZE(I) / 4 * xx;
             int x_min = XSIZE(I) / 4 * (xx-1);
 
             double mean = 0.0;
             int count = 0;
             double var_i = 0.0;
             double var_o = 0.0;
 
             for (int y = y_min; y < y_max; y++)
             {
                 for (int x = x_min; x < x_max; x++)
                 {
                     mean += DIRECT_A2D_ELEM(I,y,x);
                     count++;
                 }
             }
             mean = mean / count;
 
             for (int y = y_min; y < y_max; y++)
             {
                 for (int x = x_min; x < x_max; x++)
                 {
                     if (yy > 1 && yy < 4 && xx > 1 && xx < 4)
                         var_i += (DIRECT_A2D_ELEM(I,y,x) - mean) *
                                  (DIRECT_A2D_ELEM(I,y,x) - mean);
                     else
                         var_o += (DIRECT_A2D_ELEM(I,y,x) - mean) *
                                  (DIRECT_A2D_ELEM(I,y,x) - mean);
                 }
             }
 
             if (yy > 1 && yy < 4 && xx > 1 && xx < 4)
             {
                 var_i_sum += var_i / count;
                 fv.push_back(var_i / count);
             }
             else
             {
                 var_o_sum += var_o / count;
                 fv.push_back(var_o / count);
             }
         }
     }
 
     fv.push_back((var_i_sum / 4) / (var_o_sum / 12));
 }

◆ extractZernike()

void ProgExtractFeatures::extractZernike	(	const MultidimArray< double > &	I,
		std::vector< double > &	fv
	)

Extracting Zernike moments See method at A. Tahmasbi, F. Saki, S. B. Shokouhi, Classification of Benign and Malignant Masses Based on Zernike Moments, Comput. Biol. Med., vol. 41, no. 8, pp. 726-735, 2011 and also F. Saki, A. Tahmasbi, H. Soltanian-Zadeh, S. B. Shokouhi, Fast opposite weight learning rules with application in breast cancer diagnosis, Comput. Biol. Med., vol. 43, no. 1, pp. 32-41, 2013.

Definition at line 510 of file classify_extract_features.cpp.

 {
     MultidimArray<double> R, Theta, Rad;
     R.resize(I); R.setXmippOrigin();
     Theta.resize(I); Theta.setXmippOrigin();
     Rad.resize(I); Rad.setXmippOrigin();
 
     double c;
     int Sy = YSIZE(I);
     int Sx = XSIZE(I);
     const std::complex<double> i(0.0, 1.0);
 
     for (int y = 0; y < Sy; y++)
     {
         int r2 = 2*(y+1)-Sy-1;
 
         for (int x = 0; x < Sx; x++)
         {
             int r1 = 2*(x+1)-Sy-1;
             DIRECT_A2D_ELEM(R,y,x) = sqrt(r1*r1 + r2*r2) / Sy;
             if (DIRECT_A2D_ELEM(R,y,x) > 1) DIRECT_A2D_ELEM(R,y,x) = 0;
 
             DIRECT_A2D_ELEM(Theta,y,x) = atan2((Sy+1-2*(y+1)), (2*(x+1)-Sy-1));
         }
     }
 
     for (int n = 1; n < 5; n++)
     {
         for (int m = -n; m < 0; m+=2)
         {
             int mn = (n - abs(m)) / 2;
             int nm = (n + abs(m)) / 2;
             std::complex<double> product = 0.0;
 
             for (int y = 0; y < Sy; y++)
             {
                 for (int x = 0; x < Sx; x++)
                 {
                     DIRECT_A2D_ELEM(Rad,y,x) = 0;
                     for (int s = 0; s <= mn; s++)
                     {
                         int ns = n - 2*s;
                         c = ((s%2 == 0) ? 1 : -1) *
                             facs(n-s) / (facs(s) *
                             facs(nm-s) *
                             facs(mn-s));
 
                         DIRECT_A2D_ELEM(Rad,y,x) += c *
                             pow(DIRECT_A2D_ELEM(R,y,x), ns);
                     }
 
                     product += DIRECT_A2D_ELEM(I,y,x) *
                                DIRECT_A2D_ELEM(Rad,y,x) *
                                exp(-1.0 * i * (double)m *
                                    DIRECT_A2D_ELEM(Theta,y,x));
                 }
             }
             fv.push_back(std::abs(product));
         }
     }
 }

◆ facs()

int ProgExtractFeatures::facs ( int n )

Function for returning factorial up to n=4.

Definition at line 90 of file classify_extract_features.cpp.

 {
     return (n == 1 || n == 0) ? 1 :
            (n == 2) ? 2 :
            (n == 3) ? 6 : 24;
 }

◆ operator=() [1/2]

ProgExtractFeatures& ProgExtractFeatures::operator= ( const ProgExtractFeatures & )

delete

◆ operator=() [2/2]

ProgExtractFeatures& ProgExtractFeatures::operator= ( const ProgExtractFeatures && )

delete

◆ readParams()

void ProgExtractFeatures::readParams ( )

virtual

Read argument.

Reimplemented from XmippProgram.

Definition at line 40 of file classify_extract_features.cpp.

 {
     fnSel = getParam("-i");
     fnOut = getParam("-o");
     applyDenoising = checkParam("--applyDenoising");
     useEntropy = checkParam("--entropy");
     useGranulo = checkParam("--granulo");
     useHistDist = checkParam("--histdist");
     useLBP = checkParam("--lbp");
     useRamp = checkParam("--ramp");
     useVariance = checkParam("--variance");
     useZernike = checkParam("--zernike");
 }

◆ run()

void ProgExtractFeatures::run ( )

virtual

Main routine.

Reimplemented from XmippProgram.

Definition at line 574 of file classify_extract_features.cpp.

 {
     MetaDataVec SF;
     SF.read(fnSel);
     Image<double> I, Imasked;
     FileName fnImg;
     CorrelationAux aux;
     std::vector<double> fv;
 
     if (verbose>0)
         init_progress_bar(SF.size());
     size_t idx=0;
     for (size_t objId : SF.ids())
     {
         SF.getValue(MDL_IMAGE, fnImg, objId);
         I.read(fnImg);
         I().setXmippOrigin();
         centerImageTranslationally(I(), aux);
 
         if (applyDenoising)
             denoiseTVFilter(I(), 200);
 
         if (useEntropy)
         {
             extractEntropy(I(), Imasked(), fv);
             SF.setValue(MDL_SCORE_BY_ENTROPY, fv, objId);
             fv.clear();
         }
         if (useGranulo)
         {
             extractGranulo(I(), fv);
             SF.setValue(MDL_SCORE_BY_GRANULO, fv, objId);
             fv.clear();
         }
         if (useHistDist)
         {
             extractHistDist(I(), fv);
             SF.setValue(MDL_SCORE_BY_HISTDIST, fv, objId);
             fv.clear();
         }
         if (useLBP)
         {
             extractLBP(I(), fv);
             SF.setValue(MDL_SCORE_BY_LBP, fv, objId);
             fv.clear();
         }
         if (useRamp)
         {
             extractRamp(I(), fv);
             SF.setValue(MDL_SCORE_BY_RAMP, fv, objId);
             fv.clear();
         }
         if (useVariance)
         {
             extractVariance(I(), fv);
             SF.setValue(MDL_SCORE_BY_VARIANCE, fv, objId);
             fv.clear();
         }
         if (useZernike)
         {
             extractZernike(I(), fv);
             SF.setValue(MDL_SCORE_BY_ZERNIKE, fv, objId);
             fv.clear();
         }
 
         idx++;
         if (idx%100==0 && verbose>0)
             progress_bar(idx);
     }
     if (verbose>0) progress_bar(SF.size());
     if (fnOut == "") fnOut = fnSel;
     SF.write(fnOut, MD_APPEND);
 }

◆ show()

void ProgExtractFeatures::show ( )

Show.

Definition at line 55 of file classify_extract_features.cpp.

 {
     if (verbose==0)
         return;
     std::cerr
     << "Input selfile:             " << fnSel          << std::endl
     << "Output selfile:            " << fnOut          << std::endl
     << "Turn on denoising:         " << applyDenoising << std::endl
     << "Extract entropy features:  " << useEntropy     << std::endl
     << "Extract granulo features:  " << useGranulo     << std::endl
     << "Extract histog. distances: " << useHistDist    << std::endl
     << "Extract LBP features:      " << useLBP         << std::endl
     << "Extract ramp coefficients: " << useRamp        << std::endl
     << "Extract variance features: " << useVariance    << std::endl
     << "Extract Zernike moments:   " << useZernike     << std::endl
     ;
 }