AutoParticlePicking2 Class Reference

#include <micrograph_automatic_picking2.h>

Collaboration diagram for AutoParticlePicking2:

Public Member Functions
	AutoParticlePicking2 (int particle_size, int filter_num=6, int corr_num=2, int NPCA=4, const FileName &model_name=nullptr, const std::vector< MDRowSql > &vMicList={})
	Constructor. More...
	AutoParticlePicking2 ()=default
	~AutoParticlePicking2 ()
	Destructor. More...
void	setSize (int pSize)
void	readMic (const FileName &fn_micrograph, int keepPrev)
	Read micrograph from the file. More...
void	filterBankGenerator ()
void	batchBuildInvariant (const std::vector< MDRowSql > &MD)
void	buildInvariant (const std::vector< MDRowSql > &MD)
void	extractInvariant ()
void	extractPositiveInvariant ()
void	extractNegativeInvariant ()
void	trainPCA ()
void	add2Dataset (int flagNegPos)
void	train (const std::vector< MDRowSql > &MD, bool corrFlag, int x, int y, int width, int height)
void	correction (const std::vector< MDRowSql > &addedParticlesMD, const std::vector< MDRowSql > &removedParticlesMD)
void	add2Dataset (const MetaData &removedParticlesMD)
void	saveTrainingSet ()
int	automaticallySelectParticles (FileName fnmicrograph, int proc_prec, std::vector< MDRowSql > &md)
int	automaticWithouThread (FileName fnmicrograph, int proc_prec, const FileName &fn)
void	saveAutoParticles (MetaData &md)
void	saveAutoParticles (std::vector< MDRowSql > &md)
void	readParams (XmippProgram *program)
	Read the parmaeters of the main program. More...
void	readMicrograph ()
	Read the micrograph in memory. More...
bool	checkDist (Particle2 &p)
void	extractStatics (MultidimArray< double > &inputVec, MultidimArray< double > &features)
void	convert2PolarFourier (MultidimArray< double > &particleImage, MultidimArray< std::complex< double > > &polar)
	Convert an image to its polar form. More...
void	polarCorrelation (const MultidimArray< std::complex< double > > &fourierPolarStack, MultidimArray< double > &IpolarCorr)
	Calculate the correlation of different polar channels. More...
void	applyConvolution (bool fast)
	Convolve the micrograph with the different templates. More...
double	PCAProject (MultidimArray< double > &pcaBasis, MultidimArray< double > &vec)
	Project a vector on one pca basis. More...
void	extractParticle (const int x, const int y, MultidimArray< double > &filter, MultidimArray< double > &particleImage, bool normal)
void	extractNonParticle (std::vector< Particle2 > &negativePosition)
void	extractInvariant (const FileName &fnInvariantFeat, const FileName &fnParticles, bool avgFlag)
void	extractPositiveInvariant (const FileName &fnInvariantFeat, const FileName &fnParticles, bool avgFlag)
void	extractNegativeInvariant (const FileName &fnInvariantFeat, const FileName &fnParticles)
void	buildVector (MultidimArray< double > &inputVec, MultidimArray< double > &staticVec, MultidimArray< double > &featureVec, MultidimArray< double > &pieceImage)
void	buildInvariant (MultidimArray< double > &invariantChannel, int x, int y, int pre)
void	buildSearchSpace (std::vector< Particle2 > &positionArray, bool fast)
void	trainSVM (const FileName &fnModel, int numClassifier)
void	trainPCA (const FileName &fnPositiveFeat)
void	trainRotPCA (const FileName &fnAvgModel, const FileName &fnPCARotModel)
void	add2Dataset (const FileName &fnInvariantFeat, const FileName &fnParticles, int lable)
void	add2Dataset ()
void	normalizeDataset (int a, int b)
void	savePCAModel (const FileName &fn)
	Save the PCA basis and average for each channel. More...
void	saveTrainingSet (const FileName &fn_root)
	Save training set into memory. More...
void	loadTrainingSet (const FileName &fn_root)
	Load training set into the related array. More...
void	generateTrainSet ()
void	generateFeatVec (const FileName &fnmicrograph, int proc_prec, std::vector< Particle2 > &positionArray)
int	readNextMic (FileName &fnmicrograph)
int	getParticlesThreshold ()

Static Public Member Functions
static void	defineParams (XmippProgram *program)
	Define the parameters of the main program. More...

Public Attributes
int	particle_size
int	particle_radius
int	filter_num
int	proc_prec
int	NPCA
int	NRPCA
int	corr_num
int	num_correlation
int	num_features
int	Nthreads
int	fast
int	NRsteps
SVMClassifier	classifier
SVMClassifier	classifier2
PCAMahalanobisAnalyzer	pcaAnalyzer
ProgImageRotationalPCA	rotPcaAnalyzer
Micrograph::Point	p1
Micrograph::Point	p2
FeaturesThread *	thread
Micrograph	m
Micrograph	mPrev
Image< double >	microImage
Image< double >	micrographStack
Image< double >	micrographStackPre
Image< double >	microImagePrev
std::vector< Particle2 >	auto_candidates
std::vector< Particle2 >	rejected_particles
std::vector< Particle2 >	accepted_particles
std::vector< Particle2 >	negative_candidates
std::vector< MDRowSql >	micList
FileName	fn_micrograph
FileName	fn_model
FileName	fnPCAModel
FileName	fnPCARotModel
FileName	fnAvgModel
FileName	fnVector
FileName	fnSVMModel
FileName	fnSVMModel2
FileName	fnInvariant
FileName	fnParticles
double	scaleRate
MultidimArray< double >	convolveRes
MultidimArray< double >	filterBankStack
MultidimArray< double >	positiveParticleStack
MultidimArray< double >	negativeParticleStack
MultidimArray< double >	positiveInvariatnStack
MultidimArray< double >	negativeInvariatnStack
MultidimArray< double >	autoFeatVec
MultidimArray< double >	pcaModel
MultidimArray< double >	pcaRotModel
MultidimArray< double >	particleAvg
MultidimArray< double >	dataSet
MultidimArray< double >	dataSet1
MultidimArray< double >	classLabel
MultidimArray< double >	classLabel1
MultidimArray< double >	labelSet
MultidimArray< double >	dataSetNormal

Static Public Attributes
static const int	NangSteps =120

Detailed Description

Class to perform the automatic particle picking

Definition at line 61 of file micrograph_automatic_picking2.h.

Constructor & Destructor Documentation

AutoParticlePicking2() [1/2]

AutoParticlePicking2::AutoParticlePicking2	(	int	particle_size,
		int	filter_num = 6,
		int	corr_num = 2,
		int	NPCA = 4,
		const FileName &	model_name = nullptr,
		const std::vector< MDRowSql > &	vMicList = {}
	)

Constructor.

Definition at line 38 of file micrograph_automatic_picking2.cpp.

{
    // Defining the paths for pca, svm, ... models.
    fn_model=model_name;
    fnPCAModel=fn_model+"_pca_model.stk";
    fnPCARotModel=fn_model+"_rotpca_model.stk";
    fnAvgModel=fn_model+"_particle_avg.xmp";
    fnVector=fn_model+"_training.txt";
    fnSVMModel=fn_model+"_svm.txt";
    fnSVMModel2=fn_model+"_svm2.txt";
    fnInvariant=fn_model+"_invariant";
    fnParticles=fn_model+"_particle";

    // Reading the list of micrographs
    //    if (strcmp(micsFn.c_str()," "))
    //        micList.read(micsFn);

    micList = vMicList;
    // Setting the values of the parameters
    corr_num=corrNum;
    filter_num=filterNum;
    NPCA=basisPCA;
    NRPCA=20;
    num_correlation=filterNum+((filterNum-corr_num)*corr_num);
    num_features=num_correlation*NPCA+NRPCA+12;
    setSize(pSize);

    // Set the parameters for two SVM classifiers.
    classifier.setParameters(8.0, 0.125);
    classifier2.setParameters(1.0, 0.25);

    // If models were generated then load them to memory.
    if (fnPCAModel.exists())
    {
        particleAvg.initZeros(particle_size+1,particle_size+1);
        particleAvg.setXmippOrigin();
        Image<double> II;
        II.read(fnPCAModel);
        pcaModel=II();
        // Read rotational PCA model
        II.read(fnPCARotModel);
        pcaRotModel=II();
        // Read the average of the particles for convolution
        II.read(fnAvgModel);
        particleAvg=II();
        classifier.LoadModel(fnSVMModel);
    }

    // Initalize the thread to one
    thread = nullptr;
}

AutoParticlePicking2() [2/2]

AutoParticlePicking2::AutoParticlePicking2 ( )

default

~AutoParticlePicking2()

AutoParticlePicking2::~AutoParticlePicking2

(

)

Destructor.

Definition at line 1018 of file micrograph_automatic_picking2.cpp.

{}

Member Function Documentation

add2Dataset() [1/4]

void AutoParticlePicking2::add2Dataset

(

int

flagNegPos

)

Definition at line 384 of file micrograph_automatic_picking2.cpp.

{
    MultidimArray<double> vec;
    MultidimArray<double> staticVec;
    MultidimArray<double> avg;
    MultidimArray<double> pcaBase;
    MultidimArray<double> pcaRBase;

    int steps;
    int yDataSet=YSIZE(dataSet);

    if (!flagNegPos)
        steps=NSIZE(positiveInvariatnStack)/num_correlation;
    else
        steps=NSIZE(negativeInvariatnStack)/num_correlation;
    // Resize the dataset for the new data
    dataSet.resize(1,1,yDataSet+steps,num_features);
    classLabel.resize(1,1,1,YSIZE(dataSet));
    for (size_t n=yDataSet;n<XSIZE(classLabel);n++)
    {
        if (!flagNegPos)
            classLabel(n)=1;
        else
            classLabel(n)=2;
    }
    // Here we take each channel of the particle and try to project it
    // on related PCA basis. So we first do it for first channel and obtain
    // all the features for all particles and then move to the next channel.
    for (int i=0;i<num_correlation;i++)
    {
        avg.aliasImageInStack(pcaModel,i*(NPCA+1));
        avg.resize(1,1,XSIZE(avg)*YSIZE(avg));
        for (int j=0;j<NPCA;j++)
        {
            pcaBase.aliasImageInStack(pcaModel,i*(NPCA+1)+1+j);
            pcaBase.resize(1,1,1,XSIZE(pcaBase)*YSIZE(pcaBase));
            for (int k=0;k<steps;k++)
            {
                vec.resize(1 , NangSteps, NRsteps);
                if (!flagNegPos)
                    positiveInvariatnStack.getImage(k*num_correlation+i, vec);
                else
                    negativeInvariatnStack.getImage(k*num_correlation+i, vec);
                vec.resize(1, 1, XSIZE(vec)*YSIZE(vec));
                vec-=avg;
                DIRECT_A2D_ELEM(dataSet,k+yDataSet,j+(i*NPCA))=PCAProject(pcaBase,vec);
            }
        }
    }

    // Obtain the statics for each particle
    for (int i=0;i<steps;i++)
    {
        vec.resize(1 , particle_size+1, particle_size+1);
        if (!flagNegPos)
            positiveParticleStack.getImage(i, vec);
        else
            negativeParticleStack.getImage(i, vec);
        vec.resize(1,1,1,XSIZE(vec)*YSIZE(vec));
        extractStatics(vec,staticVec);
        for (int j=0;j<12;j++)
            DIRECT_A2D_ELEM(dataSet,i+yDataSet,j+num_correlation*NPCA)=DIRECT_A1D_ELEM(staticVec,j);
        // Project each particles on rotational PCA basis.
        for (int j=0;j<NRPCA;j++)
        {
            pcaRBase.aliasImageInStack(pcaRotModel,j);
            pcaRBase.resize(1,1,1,XSIZE(pcaRBase)*YSIZE(pcaRBase));
            DIRECT_A2D_ELEM(dataSet,i+yDataSet,num_correlation*NPCA+12+j)=PCAProject(pcaRBase,vec);
        }
    }
}

add2Dataset() [2/4]

void AutoParticlePicking2::add2Dataset

(

const MetaData &

removedParticlesMD

)

Definition at line 893 of file micrograph_automatic_picking2.cpp.

{
    int cntNeg=0;
    int enabled;
    double cost;

    for (size_t objId : removedParticlesMD.ids())
    {
        removedParticlesMD.getValue(MDL_ENABLED,enabled, objId);
        if (enabled == -1)
        {
            removedParticlesMD.getValue(MDL_COST,cost, objId);
            if (cost!=-1)
                cntNeg++;
        }
    }
    int yDataSet=YSIZE(dataSet);
    dataSet.resize(1,1,yDataSet+cntNeg,num_features);
    classLabel.resize(1,1,1,YSIZE(dataSet));
    int limit = cntNeg + yDataSet;
    for (int n=yDataSet;n<limit;n++)
        classLabel(n)=3;
    int cnt=0;

    for (size_t objId : removedParticlesMD.ids())
    {
        removedParticlesMD.getValue(MDL_ENABLED,enabled, objId);
        if (enabled == -1)
        {
            removedParticlesMD.getValue(MDL_COST,cost, objId);
            if (cost!=-1)
            {
                for (size_t j=0;j<XSIZE(dataSet);j++)
                    DIRECT_A2D_ELEM(dataSet,cnt+yDataSet,j)=DIRECT_A1D_ELEM(auto_candidates[cnt].vec,j);
                cnt++;
            }
        }
    }
}

add2Dataset() [3/4]

void AutoParticlePicking2::add2Dataset	(	const FileName &	fnInvariantFeat,
		const FileName &	fnParticles,
		int	lable
	)

Definition at line 1180 of file micrograph_automatic_picking2.cpp.

{
    ImageGeneric positiveInvariant;
    MultidimArray<double> vec;
    MultidimArray<double> staticVec;
    MultidimArray<double> avg;
    MultidimArray<double> pcaBase;
    MultidimArray<double> pcaRBase;
    MultidimArray<double> binaryVec;
    MultidimArray<double> dilatedVec;
    FourierFilter filter;
    ArrayDim aDim;
    int yDataSet=YSIZE(dataSet);
    if (!fn_Invariant.exists())
        return;
    positiveInvariant.read(fn_Invariant,HEADER);
    positiveInvariant.getDimensions(aDim);
    int steps=aDim.ndim/num_correlation;
    // Resize the dataset for the new data
    dataSet.resize(1,1,yDataSet+steps,num_features);
    classLabel.resize(1,1,1,YSIZE(dataSet));
    for (size_t n=yDataSet;n<XSIZE(classLabel);n++)
        classLabel(n)=label;
    // Here we take each channel of the particle and try to project it
    // on related PCA basis. So we first do it for first channel and obtain
    // all the features for all particles and then move to the next channel.
    for (int i=0;i<num_correlation;i++)
    {
        avg.aliasImageInStack(pcaModel,i*(NPCA+1));
        avg.resize(1,1,1,XSIZE(avg)*YSIZE(avg));
        for (int j=0;j<NPCA;j++)
        {
            pcaBase.aliasImageInStack(pcaModel,i*(NPCA+1)+1+j);
            pcaBase.resize(1,1,1,XSIZE(pcaBase)*YSIZE(pcaBase));
            for (int k=0;k<steps;k++)
            {
                positiveInvariant.readMapped(fn_Invariant,k*num_correlation+i+1);
                positiveInvariant().getImage(vec);
                vec.resize(1,1,1,XSIZE(vec)*YSIZE(vec));
                vec-=avg;
                DIRECT_A2D_ELEM(dataSet,k+yDataSet,j+(i*NPCA))=PCAProject(pcaBase,vec);
            }
        }
    }
    // Obtain the statics for each particle
    for (int i=0;i<steps;i++)
    {
        positiveInvariant.readMapped(fnParticles,i+1);
        positiveInvariant().getImage(vec);
        vec.resize(1,1,1,XSIZE(vec)*YSIZE(vec));
        extractStatics(vec,staticVec);
        for (int j=0;j<12;j++)
            DIRECT_A2D_ELEM(dataSet,i+yDataSet,j+num_correlation*NPCA)=DIRECT_A1D_ELEM(staticVec,j);
        // Project each particles on rotational PCA basis.
        for (int j=0;j<NRPCA;j++)
        {
            pcaRBase.aliasImageInStack(pcaRotModel,j);
            pcaRBase.resize(1,1,1,XSIZE(pcaRBase)*YSIZE(pcaRBase));
            DIRECT_A2D_ELEM(dataSet,i+yDataSet,num_correlation*NPCA+12+j)=PCAProject(pcaRBase,vec);
        }
    }
    fn_Invariant.deleteFile();
    fnParticles.deleteFile();
}

add2Dataset() [4/4]

void AutoParticlePicking2::add2Dataset

(

)

Definition at line 1247 of file micrograph_automatic_picking2.cpp.

{
    // Here we have the features and we just want to put them
    // in the dataset.
    int limit=0, size=0, newSize=0;
    int yDataSet=YSIZE(dataSet);
    size_t n=0;

    newSize=rejected_particles.size()+
            accepted_particles.size();
    dataSet.resize(1,1,yDataSet+newSize,num_features);
    classLabel.resize(1,1,1,YSIZE(dataSet));
    limit=yDataSet;
    if (rejected_particles.size() > 0)
    {
        limit += rejected_particles.size();
        //        for (int n=yDataSet;n<limit;n++)
        //            classLabel(n)=2;
        for (n=0;n<rejected_particles.size();n++)
        {
            classLabel(n+yDataSet)=2;
            if (n<accepted_particles.size())
                classLabel(n+limit)=1;
            for (size_t j=0;j<XSIZE(dataSet);j++)
            {
                DIRECT_A2D_ELEM(dataSet,n+yDataSet,j)=DIRECT_A1D_ELEM(rejected_particles[n].vec,j);
                if (n<accepted_particles.size())
                    DIRECT_A2D_ELEM(dataSet,n+limit,j)=DIRECT_A1D_ELEM(accepted_particles[n].vec,j);
            }
        }
    }
    if (accepted_particles.size()>n)
    {
        size = limit+n;
        int cnt=0;
        for (size_t i=n;i<accepted_particles.size();i++)
        {
            classLabel(size+cnt)=1;
            for (size_t j=0;j<XSIZE(dataSet);j++)
                DIRECT_A2D_ELEM(dataSet,size+cnt,j)=DIRECT_A1D_ELEM(accepted_particles[i].vec,j);
            cnt++;
        }
    }
}

applyConvolution()

void AutoParticlePicking2::applyConvolution

(

bool

fast

)

Convolve the micrograph with the different templates.

Definition at line 1677 of file micrograph_automatic_picking2.cpp.

{

    MultidimArray<double> tempConvolve;
    MultidimArray<double> avgRotated, avgRotatedLarge;
    MultidimArray<int> mask;
    CorrelationAux aux;
    FourierFilter filter;
    int sizeX = XSIZE(microImage());
    int sizeY = YSIZE(microImage());

    //Generating Mask
    mask.resize(particleAvg);
    mask.setXmippOrigin();
    BinaryCircularMask(mask, XSIZE(particleAvg)/2);
    normalize_NewXmipp(particleAvg,mask);
    particleAvg.setXmippOrigin();

    filter.raised_w=0.02;
    filter.FilterShape=RAISED_COSINE;
    filter.FilterBand=BANDPASS;
    filter.w1=1.0/double(particle_size);
    filter.w2=1.0/(double(particle_size)/3);
    if (fast)
    {
        // In fast mode we just do the convolution with the average of the
        // rotated templates
        avgRotatedLarge=particleAvg;
        for (int deg=3;deg<360;deg+=3)
        {
            rotate(xmipp_transformation::LINEAR,avgRotated,particleAvg,double(deg));
            avgRotated.setXmippOrigin();
            avgRotatedLarge.setXmippOrigin();
            avgRotatedLarge+=avgRotated;
        }
        avgRotatedLarge/=120;
        avgRotatedLarge.selfWindow(FIRST_XMIPP_INDEX(sizeY),FIRST_XMIPP_INDEX(sizeX),
                                   LAST_XMIPP_INDEX(sizeY),LAST_XMIPP_INDEX(sizeX));
        correlation_matrix(microImage(),avgRotatedLarge,convolveRes,aux,false);
        filter.do_generate_3dmask=true;
        filter.generateMask(convolveRes);
        filter.applyMaskSpace(convolveRes);
    }
    else
    {
        avgRotatedLarge=particleAvg;
        avgRotatedLarge.selfWindow(FIRST_XMIPP_INDEX(sizeY),FIRST_XMIPP_INDEX(sizeX),
                                   LAST_XMIPP_INDEX(sizeY),LAST_XMIPP_INDEX(sizeX));
        correlation_matrix(microImage(),avgRotatedLarge,convolveRes,aux,false);
        filter.do_generate_3dmask=true;
        filter.generateMask(convolveRes);
        filter.applyMaskSpace(convolveRes);

        for (int deg=3;deg<360;deg+=3)
        {
            // We first rotate the template and then put it in the big image in order to
            // the convolution
            rotate(xmipp_transformation::LINEAR,avgRotated,particleAvg,double(deg));
            avgRotatedLarge=avgRotated;
            avgRotatedLarge.setXmippOrigin();
            avgRotatedLarge.selfWindow(FIRST_XMIPP_INDEX(sizeY),FIRST_XMIPP_INDEX(sizeX),
                                       LAST_XMIPP_INDEX(sizeY),LAST_XMIPP_INDEX(sizeX));
            correlation_matrix(aux.FFT1,avgRotatedLarge,tempConvolve,aux,false);
            filter.applyMaskSpace(tempConvolve);
            FOR_ALL_DIRECT_ELEMENTS_IN_ARRAY2D(convolveRes)
            if (DIRECT_A2D_ELEM(tempConvolve,i,j)>DIRECT_A2D_ELEM(convolveRes,i,j))
                DIRECT_A2D_ELEM(convolveRes,i,j)=DIRECT_A2D_ELEM(tempConvolve,i,j);
        }
    }
    CenterFFT(convolveRes,true);
}

automaticallySelectParticles()

int AutoParticlePicking2::automaticallySelectParticles	(	FileName	fnmicrograph,
		int	proc_prec,
		std::vector< MDRowSql > &	md
	)

Definition at line 540 of file micrograph_automatic_picking2.cpp.

{
    // bool error=MDSql::deactivateThreadMuting();
    auto_candidates.clear();
    //    md.clear();

    double label, score;
    Particle2 p;
    MultidimArray<double> featVec, featVecNN;
    std::vector<Particle2> positionArray;

    if (thread == nullptr)
    {
        thread = new FeaturesThread(this);
        thread->start();
        thread->workOnMicrograph(fnmicrograph, proc_prec);
    }
    if (strcmp(fnmicrograph.c_str(),thread->fnmicrograph.c_str()))
    {
        flagAbort=1;
        thread->waitForResults();
        flagAbort=0;
        positionArray.clear();
        generateFeatVec(fnmicrograph,proc_prec,positionArray);
    }
    else
    {
        thread->waitForResults();
        positionArray = thread->positionArray;
    }

    // Read the SVM model
    //    generateFeatVec(fnmicrograph,proc_prec,positionArray);
    //    classifier.LoadModel(fnSVMModel);
    auto num=(int)(positionArray.size()*(proc_prec/100.0));
    featVec.resize(num_features);
    //    negative_candidates.clear();

    for (int k=0;k<num;k++)
    {
        FOR_ALL_DIRECT_ELEMENTS_IN_ARRAY1D(featVec)
        DIRECT_A1D_ELEM(featVec,i)=DIRECT_A2D_ELEM(autoFeatVec,k,i);
        featVecNN=featVec;
        double max=featVec.computeMax();
        double min=featVec.computeMin();
        FOR_ALL_DIRECT_ELEMENTS_IN_ARRAY1D(featVec)
        DIRECT_A1D_ELEM(featVec,i)=0+(1*((DIRECT_A1D_ELEM(featVec,i)-min)/(max-min)));
        int j=positionArray[k].x;
        int i=positionArray[k].y;
        label= classifier.predict(featVec, score);
        if (label==1)
        {
            p.x=j;
            p.y=i;
            p.status=1;
            p.cost=score;
            p.vec=featVecNN;
            auto_candidates.push_back(p);

        }
        //        else
        //        {
        //            p.x=j;
        //            p.y=i;
        //            p.status=1;
        //            p.cost=score;
        //            p.vec=featVecNN;
        //            negative_candidates.push_back(p);
        //        }
    }
    if (auto_candidates.size() == 0)
        return 0;
    // Remove the occluded particles
    for (size_t i=0;i<auto_candidates.size();++i)
        for (size_t j=0;j<auto_candidates.size()-i-1;j++)
            if (auto_candidates[j].cost<auto_candidates[j+1].cost)
            {
                p=auto_candidates[j+1];
                auto_candidates[j+1]=auto_candidates[j];
                auto_candidates[j]=p;
            }
    for (size_t i=0;i<auto_candidates.size()-1;++i)
    {
        if (auto_candidates[i].status==-1)
            continue;
        p=auto_candidates[i];
        for (size_t j=i+1;j<auto_candidates.size();j++)
        {
            if (auto_candidates[j].x>p.x-particle_radius
                && auto_candidates[j].x<p.x+particle_radius
                && auto_candidates[j].y>p.y-particle_radius
                && auto_candidates[j].y<p.y+particle_radius)
            {
                if (p.cost<auto_candidates[j].cost)
                {
                    auto_candidates[i].status=-1;
                    p=auto_candidates[j];
                }
                else
                    auto_candidates[j].status=-1;
            }
        }
    }
    saveAutoParticles(md);
    if (readNextMic(fnmicrograph))
        thread->workOnMicrograph(fnmicrograph, proc_prec);
    return auto_candidates.size();
}

automaticWithouThread()

int AutoParticlePicking2::automaticWithouThread	(	FileName	fnmicrograph,
		int	proc_prec,
		const FileName &	fn
	)

Definition at line 649 of file micrograph_automatic_picking2.cpp.

{
    // Read the SVM model
    //    classifier.LoadModel(fnSVMModel);

    double label, score;
    Particle2 p;
    MultidimArray<double> featVec, featVecNN;
    std::vector<Particle2> positionArray;
    MetaDataVec md;

    generateFeatVec(fnmicrograph,proc_prec,positionArray);

    auto num=(int)(positionArray.size()*(proc_prec/100.0));
    featVec.resize(num_features);
    for (int k=0;k<num;k++)
    {
        FOR_ALL_DIRECT_ELEMENTS_IN_ARRAY1D(featVec)
        DIRECT_A1D_ELEM(featVec,i)=DIRECT_A2D_ELEM(autoFeatVec,k,i);
        featVecNN=featVec;
        double max=featVec.computeMax();
        double min=featVec.computeMin();
        FOR_ALL_DIRECT_ELEMENTS_IN_ARRAY1D(featVec)
        DIRECT_A1D_ELEM(featVec,i)=0+((1)*((DIRECT_A1D_ELEM(featVec,i)-min)/(max-min)));
        int j=positionArray[k].x;
        int i=positionArray[k].y;
        label= classifier.predict(featVec, score);
        if (label==1)
        {
            p.x=j;
            p.y=i;
            p.status=1;
            p.cost=score;
            p.vec=featVecNN;
            auto_candidates.push_back(p);

        }
    }

    if (auto_candidates.size() == 0)
        return 0;
    // Remove the occluded particles
    for (size_t i=0;i<auto_candidates.size();++i)
        for (size_t j=0;j<auto_candidates.size()-i-1;j++)
            if (auto_candidates[j].cost<auto_candidates[j+1].cost)
            {
                p=auto_candidates[j+1];
                auto_candidates[j+1]=auto_candidates[j];
                auto_candidates[j]=p;
            }
    for (size_t i=0;i<auto_candidates.size()-1;++i)
    {
        if (auto_candidates[i].status==-1)
            continue;
        p=auto_candidates[i];
        for (size_t j=i+1;j<auto_candidates.size();j++)
        {
            if (auto_candidates[j].x>p.x-particle_radius
                && auto_candidates[j].x<p.x+particle_radius
                && auto_candidates[j].y>p.y-particle_radius
                && auto_candidates[j].y<p.y+particle_radius)
            {
                if (p.cost<auto_candidates[j].cost)
                {
                    auto_candidates[i].status=-1;
                    p=auto_candidates[j];
                }
                else
                    auto_candidates[j].status=-1;
            }
        }
    }
    saveAutoParticles(md);
    md.write(fn,MD_OVERWRITE);
    return auto_candidates.size();
}

batchBuildInvariant()

void AutoParticlePicking2::batchBuildInvariant

(

const std::vector< MDRowSql > &

MD

)

Definition at line 172 of file micrograph_automatic_picking2.cpp.

{
    int x, y, flag=0;
    FileName micFile, posFile, preMicFile;

    MD[0].getValue(MDL_MICROGRAPH,preMicFile);
    readMic(preMicFile,0);
    for (size_t i=0;i<MD.size();i++)
    {
        MD[i].getValue(MDL_MICROGRAPH,micFile);
        if (strcmp(micFile.c_str(),preMicFile.c_str()))
        {
            flag = 1;
            readMic(micFile,0);
            extractInvariant(fnInvariant,fnParticles,false);
        }
        preMicFile=micFile;
        if (i==(MD.size()-1))
        {
            mPrev.point1=p1;
            mPrev.point2=p2;
            flag = 0;
        }
        else
            mPrev.point1.x=-1;
        MD[i].getValue(MDL_XCOOR,x);
        MD[i].getValue(MDL_YCOOR,y);
        mPrev.add_coord(x,y,0,1);
    }
    if (!flag)
        extractInvariant(fnInvariant,fnParticles,false);

    Image<double> II;
    II()=particleAvg;
    II.write(fnAvgModel);
}

buildInvariant() [1/2]

void AutoParticlePicking2::buildInvariant

(

const std::vector< MDRowSql > &

MD

)

Definition at line 159 of file micrograph_automatic_picking2.cpp.

{
    int x, y;
    mPrev.point1.x=-1;
    for (size_t i=0;i<MD.size();i++)
    {
        MD[i].getValue(MDL_XCOOR,x);
        MD[i].getValue(MDL_YCOOR,y);
        mPrev.add_coord(x,y,0,1);
    }
    extractInvariant(fnInvariant,fnParticles,true);
}

buildInvariant() [2/2]

void AutoParticlePicking2::buildInvariant	(	MultidimArray< double > &	invariantChannel,
		int	x,
		int	y,
		int	pre
	)

Definition at line 1076 of file micrograph_automatic_picking2.cpp.

{
    MultidimArray<double> pieceImage;
    MultidimArray< std::complex< double > > fourierPolarStack, fourierPolar;
    MultidimArray<double> filter;
    MultidimArray< std::complex<double> > tmpFourier;
    FourierTransformer transformer;
    pieceImage.resize(NangSteps,NRsteps);
    transformer.FourierTransform(pieceImage,tmpFourier);
    fourierPolarStack.initZeros(filter_num,1,YSIZE(tmpFourier),XSIZE(tmpFourier));
    // First put the polar channels in a stack
    for (int j=0;j<filter_num;++j)
    {
        if (pre)
            filter.aliasImageInStack(micrographStackPre(),j);
        else
            filter.aliasImageInStack(micrographStack(),j);
        extractParticle(x,y,filter,pieceImage,true);
        fourierPolar.aliasImageInStack(fourierPolarStack,j);
        convert2PolarFourier(pieceImage,fourierPolar);
    }
    // Obtain the correlation between different channels
    polarCorrelation(fourierPolarStack,invariantChannel);
}

buildSearchSpace()

void AutoParticlePicking2::buildSearchSpace	(	std::vector< Particle2 > &	positionArray,
		bool	fast
	)

Definition at line 1648 of file micrograph_automatic_picking2.cpp.

{
    int endX,endY;
    Particle2 p;

    endX=XSIZE(microImage())-particle_radius;
    endY=YSIZE(microImage())-particle_radius;
    applyConvolution(fast);

    for (int i=particle_radius;i<endY;i++)
        for (int j=particle_radius;j<endX;j++)
            if (isLocalMaxima(convolveRes,j,i))
            {
                p.y=i;
                p.x=j;
                p.cost=DIRECT_A2D_ELEM(convolveRes,i,j);
                p.status=0;
                positionArray.push_back(p);
            }
    for (size_t i=0;i<positionArray.size();++i)
        for (size_t j=0;j<positionArray.size()-i-1;j++)
            if (positionArray[j].cost<positionArray[j + 1].cost)
            {
                p=positionArray[j+1];
                positionArray[j+1]=positionArray[j];
                positionArray[j]=p;
            }
}

buildVector()

void AutoParticlePicking2::buildVector	(	MultidimArray< double > &	inputVec,
		MultidimArray< double > &	staticVec,
		MultidimArray< double > &	featureVec,
		MultidimArray< double > &	pieceImage
	)

Definition at line 1036 of file micrograph_automatic_picking2.cpp.

{
    MultidimArray<double> avg;
    MultidimArray<double> pcaBase;
    MultidimArray<double> pcaRBase;
    MultidimArray<double> vec;

    featureVec.resize(1,1,1,num_features);
    // Read the polar correlation from the stack and project on
    // PCA basis and put the value as the feature.
    for (int i=0;i<num_correlation;i++)
    {
        avg.aliasImageInStack(pcaModel,i*(NPCA + 1));
        avg.resize(1,1,1,XSIZE(avg)*YSIZE(avg));
        vec.aliasImageInStack(inputVec, i);
        vec.resize(1,1,1,XSIZE(vec)*YSIZE(vec));
        vec-=avg;
        for (int j=0;j<NPCA;j++)
        {
            pcaBase.aliasImageInStack(pcaModel,(i*(NPCA+1)+1)+j);
            pcaBase.resize(1,1,1,XSIZE(pcaBase)*YSIZE(pcaBase));
            DIRECT_A1D_ELEM(featureVec,j+(i*NPCA))=PCAProject(pcaBase,vec);
        }
    }
    // Extract the statics from the image
    for (int j=0;j<12;j++)
        DIRECT_A1D_ELEM(featureVec,j+num_correlation*NPCA)=DIRECT_A1D_ELEM(staticVec,j);

    // Projecting the image on rotational PCA basis
    for (int j=0;j<NRPCA;j++)
    {
        pcaRBase.aliasImageInStack(pcaRotModel,j);
        pcaRBase.resize(1,1,1,XSIZE(pcaRBase)*YSIZE(pcaRBase));
        DIRECT_A1D_ELEM(featureVec,num_correlation*NPCA+12+j)=PCAProject(pcaRBase,pieceImage);
    }
}

checkDist()

bool AutoParticlePicking2::checkDist

(

Particle2 &

p

)

Definition at line 962 of file micrograph_automatic_picking2.cpp.

{
    int num_part=mPrev.ParticleNo();
    int dist=0,min;
    Particle2 posSample;

    posSample.x=(int)((mPrev.coord(0).X)*scaleRate);
    posSample.y=(int)((mPrev.coord(0).Y)*scaleRate);
    min=(int)euclidean_distance(p,posSample);
    for (int i=1;i<num_part;i++)
    {
        posSample.x=(int)((mPrev.coord(i).X)*scaleRate);
        posSample.y=(int)((mPrev.coord(i).Y)*scaleRate);
        dist=(int)euclidean_distance(p,posSample);
        if (dist<min)
            min=dist;
    }

    if (min>(0.25*particle_radius))
        return true;
    else
        return false;
}

convert2PolarFourier()

void AutoParticlePicking2::convert2PolarFourier	(	MultidimArray< double > &	particleImage,
		MultidimArray< std::complex< double > > &	polar
	)

Convert an image to its polar form.

Definition at line 1456 of file micrograph_automatic_picking2.cpp.

{
    Matrix1D<double> R;
    MultidimArray<double> polar;
    FourierTransformer transformer;
    particleImage.setXmippOrigin();
    image_convertCartesianToPolar_ZoomAtCenter(particleImage,polar,R,1,3,
            XSIZE(particleImage)/2,NRsteps,0,2*PI,NangSteps);
    transformer.FourierTransform(polar,polarFourier,true);
}

correction()

void AutoParticlePicking2::correction	(	const std::vector< MDRowSql > &	addedParticlesMD,
		const std::vector< MDRowSql > &	removedParticlesMD
	)

Definition at line 852 of file micrograph_automatic_picking2.cpp.

{
    //    dataSet.clear();
    dataSetNormal.clear();
    //    classLabel.clear();
    //    loadTrainingSet(fnVector);
    int idx=0,enabled,x,y;
    double cost;
    accepted_particles.clear();
    rejected_particles.clear();


    for (size_t i=0;i<removedParticlesMD.size();i++)
    {
        removedParticlesMD[i].getValue(MDL_ENABLED,enabled);
        removedParticlesMD[i].getValue(MDL_XCOOR, x);
        removedParticlesMD[i].getValue(MDL_YCOOR, y);

        if (enabled == -1)
        {
            removedParticlesMD[i].getValue(MDL_COST,cost);
            if (cost!=-1.0)
                rejected_particles.push_back(auto_candidates[idx]);
        }
        else
        {
            accepted_particles.push_back(auto_candidates[idx]);
            mPrev.add_coord(x,y,0,0);
        }
        ++idx;
    }
    //    if (!addedParticlesMD.isEmpty())
    train(addedParticlesMD,true,0,0,0,0);
    add2Dataset();
    saveTrainingSet(fnVector);
    //    normalizeDataset(0,1);
    //    generateTrainSet();
    //    classifier.SVMTrain(dataSetNormal,classLabel);
    trainSVM(fnSVMModel,1);
}

defineParams()

void AutoParticlePicking2::defineParams ( XmippProgram *  program )

static

Define the parameters of the main program.

Definition at line 1778 of file micrograph_automatic_picking2.cpp.

{
    program->addParamsLine("  -i <micrograph>               : Micrograph image");
    program->addParamsLine("  --outputRoot <rootname>       : Output rootname");
    program->addParamsLine("  --mode <mode>                 : Operation mode");
    program->addParamsLine("         where <mode>");
    program->addParamsLine("                    try              : Try to autoselect within the training phase.");
    program->addParamsLine("                    train            : Train the classifier using the invariants features.");
    program->addParamsLine("                                     : <rootname>_auto_feature_vectors.txt contains the particle structure created by this program when used in automatic selection mode");
    program->addParamsLine("                                     : <rootname>_false_positives.xmd contains the list of false positives among the automatically picked particles");
    program->addParamsLine("                    autoselect  : Autoselect");
    program->addParamsLine("                    buildinv <posfile=\"\"> : posfile contains the coordinates of manually picked particles");
    program->addParamsLine("  --model <model_rootname>      : Bayesian model of the particles to pick");
    program->addParamsLine("  --particleSize <size>         : Particle size in pixels");
    program->addParamsLine("  [--thr <p=1>]                 : Number of threads for automatic picking");
    program->addParamsLine("  [--fast]                      : Perform a fast preprocessing of the micrograph (Fourier filter instead of Wavelet filter)");
    program->addParamsLine("  [--in_core]                   : Read the micrograph in memory");
    program->addParamsLine("  [--filter_num <n=6>]          : The number of filters in filter bank");
    program->addParamsLine("  [--NPCA <n=4>]               : The number of PCA components");
    program->addParamsLine("  [--NCORR <n=2>]               : The number of PCA components");
    program->addParamsLine("  [--autoPercent <n=90>]               : The number of PCA components");
    program->addExampleLine("Automatically select particles during training:", false);
    program->addExampleLine("xmipp_micrograph_automatic_picking -i micrograph.tif --particleSize 100 --model model --thr 4 --outputRoot micrograph --mode try ");
    program->addExampleLine("Training:", false);
    program->addExampleLine("xmipp_micrograph_automatic_picking -i micrograph.tif --particleSize 100 --model model --thr 4 --outputRoot micrograph --mode train manual.pos");
    program->addExampleLine("Automatically select particles after training:", false);
    program->addExampleLine("xmipp_micrograph_automatic_picking -i micrograph.tif --particleSize 100 --model model --thr 4 --outputRoot micrograph --mode autoselect");
}

extractInvariant() [1/2]

void AutoParticlePicking2::extractInvariant

(

)

Definition at line 209 of file micrograph_automatic_picking2.cpp.

{
    extractPositiveInvariant();
    extractNegativeInvariant();
}

extractInvariant() [2/2]

void AutoParticlePicking2::extractInvariant	(	const FileName &	fnInvariantFeat,
		const FileName &	fnParticles,
		bool	avgFlag
	)

Definition at line 1397 of file micrograph_automatic_picking2.cpp.

{

    extractPositiveInvariant(fnInvariantFeat,fnParticles,avgFlag);
    extractNegativeInvariant(fnInvariantFeat,fnParticles);
}

extractNegativeInvariant() [1/2]

void AutoParticlePicking2::extractNegativeInvariant

(

)

Definition at line 283 of file micrograph_automatic_picking2.cpp.

{
    MultidimArray<double> IpolarCorr;
    MultidimArray<double> randomValues;
    MultidimArray<double> pieceImage;
    MultidimArray<int> randomIndexes;
    std::vector<Particle2> negativeSamples;
    size_t numNegInv = 0;
    size_t numNegPart = 0;
    int num_part=m.ParticleNo();

    IpolarCorr.initZeros(num_correlation,1,NangSteps,NRsteps);
    // first we obtain all the places in which there could be
    // a negative particles.
    extractNonParticle(negativeSamples);
    // Choose some random positions from the previous step.
    std::random_device rd;  //Will be used to obtain a seed for the random number engine
    std::mt19937 gen(rd()); //Standard mersenne_twister_engine seeded with rd()
    std::uniform_real_distribution<> dist(0.0, 1.0);
    randomValues.resize(1,1,1,negativeSamples.size());
    FOR_ALL_DIRECT_ELEMENTS_IN_ARRAY1D(randomValues)
        DIRECT_A1D_ELEM(randomValues,i)=dist(gen);
    randomValues.indexSort(randomIndexes);
    int numNegatives;
    // If the number of particles is lower than 15 then the
    // number of the negatives is equal to 15 else it is equal
    // to the number of particles times 2.
    if (num_part<15)
        numNegatives=15;
    else
        numNegatives=num_part*2;
    if (fnPCAModel.exists())
    {
        negativeParticleStack.resize(size_t(numNegatives), 1, size_t(particle_size+1), size_t(particle_size+1));
        negativeInvariatnStack.resize(size_t(numNegatives*num_correlation), 1, size_t(NangSteps), size_t(NRsteps));
    }
    else
    {
        numNegInv = NSIZE(negativeInvariatnStack);
        numNegPart = NSIZE(negativeParticleStack);
        negativeParticleStack.resize(size_t(numNegPart+numNegatives), 1, size_t(particle_size+1), size_t(particle_size+1));
        negativeInvariatnStack.resize(size_t(numNegInv+numNegatives*num_correlation), 1, size_t(NangSteps), size_t(NRsteps));
    }
    for (int i=0;i<numNegatives;i++)
    {
        int x=negativeSamples[DIRECT_A1D_ELEM(randomIndexes,i)-1].x;
        int y=negativeSamples[DIRECT_A1D_ELEM(randomIndexes,i)-1].y;
        extractParticle(x,y,microImage(),pieceImage,false);
        pieceImage.getImage(0,negativeParticleStack,numNegPart+i);
        buildInvariant(IpolarCorr,x,y,1);
        // Put the obtained invariants in the stack
        for (size_t j=0;j<NSIZE(IpolarCorr);j++)
            IpolarCorr.getImage(j,negativeInvariatnStack,numNegInv+i*num_correlation+j);

    }
}

extractNegativeInvariant() [2/2]

void AutoParticlePicking2::extractNegativeInvariant	(	const FileName &	fnInvariantFeat,
		const FileName &	fnParticles
	)

Definition at line 1346 of file micrograph_automatic_picking2.cpp.

{
    MultidimArray<double> IpolarCorr;
    MultidimArray<double> randomValues;
    MultidimArray<double> pieceImage;
    MultidimArray<int> randomIndexes;
    std::vector<Particle2> negativeSamples;
    std::vector<Micrograph::Point> positionVec;

    int num_part=mPrev.ParticleNo();
    if (num_part==0)
        return;
    Image<double> II;
    FileName fnNegativeInvariatn=fnInvariantFeat+"_Negative.stk";
    FileName fnNegativeParticles=fnParticles+"_Negative.stk";
    IpolarCorr.initZeros(num_correlation,1,NangSteps,NRsteps);
    // first we obtain all the places in which there could be
    // a negative particles.
    extractNonParticle(negativeSamples);
    if (negativeSamples.size()==0)
        return;
    // Choose some random positions from the previous step.
    std::random_device rd;  //Will be used to obtain a seed for the random number engine
    std::mt19937 gen(rd()); //Standard mersenne_twister_engine seeded with rd()
    std::uniform_real_distribution<> dist(0.0, 1.0);
    randomValues.resize(1,1,1,negativeSamples.size());
    FOR_ALL_DIRECT_ELEMENTS_IN_ARRAY1D(randomValues)
        DIRECT_A1D_ELEM(randomValues,i)=dist(gen);
    randomValues.indexSort(randomIndexes);
    int numNegatives;
    // If the number of particles is lower than 15 then the
    // number of the negatives is equal to 15 else it is equal
    // to the number of particles times 2.
    if (num_part<15)
        numNegatives=15;
    else
        numNegatives=int(num_part/2);
    for (int i=0;i<numNegatives;i++)
    {
        int x=negativeSamples[DIRECT_A1D_ELEM(randomIndexes,i)-1].x;
        int y=negativeSamples[DIRECT_A1D_ELEM(randomIndexes,i)-1].y;
        extractParticle(x,y,microImagePrev(),pieceImage,false);
        II()=pieceImage;
        II.write(fnNegativeParticles,ALL_IMAGES,true,WRITE_APPEND);
        buildInvariant(IpolarCorr,x,y,1);
        II()=IpolarCorr;
        II.write(fnNegativeInvariatn,ALL_IMAGES,true,WRITE_APPEND);
    }
}

extractNonParticle()

void AutoParticlePicking2::extractNonParticle

(

std::vector< Particle2 > &

negativePosition

)

Definition at line 1422 of file micrograph_automatic_picking2.cpp.

{
    int endX,endY,startX,startY;
    int gridStep=particle_radius/2;
    Particle2 negSample;
    if (mPrev.point1.x==-1)
    {
        startX = particle_radius*2;
        startY = particle_radius*2;
        endX = XSIZE(microImagePrev())-particle_radius*2;
        endY = YSIZE(microImagePrev())-particle_radius*2;
    }
    else
    {
        startX = p1.x+particle_radius*2;
        startY = p1.y+particle_radius*2;
        endX = p2.x-particle_radius*2;
        endY = p2.y-particle_radius*2;
    }
    MultidimArray<double> pieceImage;


    for (int i=startY;i<endY; i=i+gridStep)
        for (int j= startX;j<endX;j=j+gridStep)
        {
            negSample.y=i;
            negSample.x=j;
            if (checkDist(negSample))
            {
                extractParticle(j,i,microImagePrev(),pieceImage,false);
                negativePosition.push_back(negSample);
            }
        }
}

extractParticle()

void AutoParticlePicking2::extractParticle	(	const int	x,
		const int	y,
		MultidimArray< double > &	filter,
		MultidimArray< double > &	particleImage,
		bool	normal
	)

Definition at line 1406 of file micrograph_automatic_picking2.cpp.

{
    int startX, startY, endX, endY;
    startX = x - particle_radius;
    startY = y - particle_radius;
    endX = x + particle_radius;
    endY = y + particle_radius;

    filter.window(particleImage, startY, startX, endY, endX);
    if (normal)
        normalize_OldXmipp(particleImage);
}

extractPositiveInvariant() [1/2]

void AutoParticlePicking2::extractPositiveInvariant

(

)

Definition at line 215 of file micrograph_automatic_picking2.cpp.

{
    MultidimArray<double> IpolarCorr;
    MultidimArray<double> pieceImage;
    MultidimArray<double> invariantImage;
    MultidimArray<double> polarImage;
    AlignmentAux aux;
    CorrelationAux aux2;
    RotationalCorrelationAux aux3;
    Matrix2D<double> M;
    int numPosInv = 0;
    int numPosPart = 0;

    int num_part = m.ParticleNo();
    Image<double> II;
    IpolarCorr.initZeros(num_correlation,1,NangSteps,NRsteps);
    if (fnPCAModel.exists())
    {
        positiveParticleStack.resize(num_part, 1, particle_size+1, particle_size+1);
        positiveInvariatnStack.resize(num_part*num_correlation, 1, NangSteps, NRsteps);
    }
    else
    {
        particleAvg.initZeros(particle_size+1,particle_size+1);
        numPosInv = NSIZE(positiveInvariatnStack);
        numPosPart = NSIZE(positiveParticleStack);
        positiveParticleStack.resize(numPosPart+num_part, 1, particle_size+1, particle_size+1);
        positiveInvariatnStack.resize(numPosInv+num_part*num_correlation, 1, NangSteps, NRsteps);
    }
    for (int i=0;i<num_part;i++)
    {
        auto x=(int)((m.coord(i).X)*scaleRate);
        auto y=(int)((m.coord(i).Y)*scaleRate);

        buildInvariant(IpolarCorr,x,y,1);
        // Keep the particles to train the classifiers
        extractParticle(x,y,microImage(),pieceImage,false);
        pieceImage.getImage(0,positiveParticleStack,numPosPart+i);
        //pieceImage.aliasImageInStack(positiveParticleStack,numPosPart+i);

        // Put the obtained invariants in the stack
        for (size_t j=0;j<NSIZE(IpolarCorr);j++)
            IpolarCorr.getImage(j,positiveInvariatnStack,numPosInv+i*num_correlation+j);
        // Compute the average of the manually picked particles after doing aligning
        // We just do it on manually picked particles and the flag show that if we
        // are in this step.
        if (!fnPCAModel.exists())
        {
            pieceImage.setXmippOrigin();
            particleAvg.setXmippOrigin();
            if (particleAvg.computeMax()==0)
                particleAvg+=pieceImage;
            else
            {
                alignImages(particleAvg,pieceImage,M,true,aux,aux2,aux3);
                particleAvg+=pieceImage;
            }
        }
    }
    if (!fnPCAModel.exists())
    {
        particleAvg/=num_part;
        Image<double> II;
        II()=particleAvg;
        II.write(fnAvgModel);
    }
}

extractPositiveInvariant() [2/2]

void AutoParticlePicking2::extractPositiveInvariant	(	const FileName &	fnInvariantFeat,
		const FileName &	fnParticles,
		bool	avgFlag
	)

Definition at line 1292 of file micrograph_automatic_picking2.cpp.

{

    MultidimArray<double> IpolarCorr;
    MultidimArray<double> pieceImage;
    AlignmentAux aux;
    CorrelationAux aux2;
    RotationalCorrelationAux aux3;
    Matrix2D<double> M;

    int num_part =mPrev.ParticleNo();
    if (num_part==0)
        return;
    Image<double> II;
    FileName fnPositiveInvariatn=fnInvariantFeat+"_Positive.stk";
    FileName fnPositiveParticles=fnParticles+"_Positive.stk";
    IpolarCorr.initZeros(num_correlation,1,NangSteps,NRsteps);

    for (int i=0;i<num_part;i++)
    {
        double cost = mPrev.coord(i).cost;
        if (cost == 0)
            continue;
        auto x=(int)((mPrev.coord(i).X)*scaleRate);
        auto y=(int)((mPrev.coord(i).Y)*scaleRate);
        buildInvariant(IpolarCorr,x,y,1);
        extractParticle(x,y,microImagePrev(),pieceImage,false);
        II()=pieceImage;
        II.write(fnPositiveParticles,ALL_IMAGES,true,WRITE_APPEND);
        // Compute the average of the manually picked particles after doing aligning
        // We just do it on manually picked particles and the flag show that if we
        // are in this step.
        if (avgFlag==false)
        {
            pieceImage.setXmippOrigin();
            particleAvg.setXmippOrigin();
            if (particleAvg.computeMax()==0)
                particleAvg=particleAvg+pieceImage;
            else
            {
                alignImages(particleAvg,pieceImage,M,true,aux,aux2,aux3);
                particleAvg=particleAvg+pieceImage;
            }
        }
        II()=IpolarCorr;
        II.write(fnPositiveInvariatn,ALL_IMAGES,true,WRITE_APPEND);
    }
    if (avgFlag==false)
        particleAvg/=num_part;
}

extractStatics()

void AutoParticlePicking2::extractStatics	(	MultidimArray< double > &	inputVec,
		MultidimArray< double > &	features
	)

Definition at line 1021 of file micrograph_automatic_picking2.cpp.

{
    MultidimArray<double> sortedVec;
    features.resize(1,1,1,12);
    DIRECT_A1D_ELEM(features,0)=inputVec.computeAvg();
    DIRECT_A1D_ELEM(features,1)=inputVec.computeStddev();
    normalize_OldXmipp(inputVec);
    // Sorting the image in order to find the quantiles
    inputVec.sort(sortedVec);
    auto step=(int)floor(XSIZE(sortedVec)*0.1);
    for (int i=2;i<12;i++)
        DIRECT_A1D_ELEM(features,i)=DIRECT_A1D_ELEM(sortedVec,(i-1)*step);
}

filterBankGenerator()

void AutoParticlePicking2::filterBankGenerator

(

)

Definition at line 131 of file micrograph_automatic_picking2.cpp.

{
    MultidimArray<double> inputMicrograph;
    MultidimArray<double> Iaux;

    inputMicrograph = microImage();
    filterBankStack.resize(size_t(filter_num), 1,
                           size_t(YSIZE(inputMicrograph)),
                           size_t(XSIZE(inputMicrograph)));
    FourierFilter filter;
    filter.raised_w=0.02;
    filter.FilterShape=RAISED_COSINE;
    filter.FilterBand=BANDPASS;
    MultidimArray<std::complex<double> > micrographFourier;
    FourierTransformer transformer;
    transformer.FourierTransform(inputMicrograph,micrographFourier,true);
    for (int i=0;i<filter_num;i++)
    {
        filter.w1=0.025*i;
        filter.w2=(filter.w1)+0.025;
        transformer.setFourier(micrographFourier);
        filter.applyMaskFourierSpace(microImage(),transformer.fFourier);
        transformer.inverseFourierTransform();
        Iaux.aliasImageInStack(filterBankStack,i);
        Iaux=inputMicrograph;
    }
}

generateFeatVec()

void AutoParticlePicking2::generateFeatVec	(	const FileName &	fnmicrograph,
		int	proc_prec,
		std::vector< Particle2 > &	positionArray
	)

Definition at line 727 of file micrograph_automatic_picking2.cpp.

{
    MultidimArray<double> IpolarCorr;
    MultidimArray<double> featVec;
    MultidimArray<double> pieceImage;
    MultidimArray<double> staticVec;

    readMic(fnmicrograph,1);
    IpolarCorr.initZeros(num_correlation,1,NangSteps,NRsteps);
    buildSearchSpace(positionArray,true);

    auto num=(int)(positionArray.size()*(proc_prec/100.0));
    autoFeatVec.resize(num,num_features);
    for (int k=0;k<num;k++)
    {
        if (flagAbort)
            return;
        int j=positionArray[k].x;
        int i=positionArray[k].y;
        buildInvariant(IpolarCorr,j,i,0);
        extractParticle(j,i,microImage(),pieceImage,false);
        pieceImage.resize(1,1,1,XSIZE(pieceImage)*YSIZE(pieceImage));
        extractStatics(pieceImage,staticVec);
        buildVector(IpolarCorr,staticVec,featVec,pieceImage);
        // Keep the features on memory to classify later on
        FOR_ALL_DIRECT_ELEMENTS_IN_ARRAY1D(featVec)
        DIRECT_A2D_ELEM(autoFeatVec,k,i)=DIRECT_A1D_ELEM(featVec,i);
    }
}

generateTrainSet()

void AutoParticlePicking2::generateTrainSet

(

)

Definition at line 1587 of file micrograph_automatic_picking2.cpp.

{
    int cnt=0;
    FOR_ALL_DIRECT_ELEMENTS_IN_ARRAY1D(classLabel)
    if (DIRECT_A1D_ELEM(classLabel,i)==1 || DIRECT_A1D_ELEM(classLabel,i)==3)
        cnt++;
    dataSet1.resize(1,1,cnt,XSIZE(dataSet));
    classLabel1.resize(1,1,1,cnt);
    cnt=0;
    FOR_ALL_DIRECT_ELEMENTS_IN_ARRAY1D(classLabel)
    {
        if (DIRECT_A1D_ELEM(classLabel,i)==1 || DIRECT_A1D_ELEM(classLabel,i)==3)
        {
            if (DIRECT_A1D_ELEM(classLabel,i)==3)
            {
                DIRECT_A1D_ELEM(classLabel1,cnt)=2;
                DIRECT_A1D_ELEM(classLabel,i)=2;
            }
            else
                DIRECT_A1D_ELEM(classLabel1,cnt)=1;
            for (size_t j=0;j<XSIZE(dataSet);j++)
                DIRECT_A2D_ELEM(dataSet1,cnt,j)=DIRECT_A2D_ELEM(dataSet,i,j);
            cnt++;
        }
    }
}

getParticlesThreshold()

int AutoParticlePicking2::getParticlesThreshold

(

)

Definition at line 846 of file micrograph_automatic_picking2.cpp.

{
    return 15;

}

loadTrainingSet()

void AutoParticlePicking2::loadTrainingSet

(

const FileName &

fn_root

)

Load training set into the related array.

Definition at line 1468 of file micrograph_automatic_picking2.cpp.

{
    int x,y;
    std::ifstream fhTrain;
    fhTrain.open(fn.c_str());
    fhTrain >>y>>x;
    dataSet.resize(1,1,y,x);
    classLabel.resize(1,1,1,y);
    // Load the train set and put the values in training array
    for (int i=0;i<y;i++)
    {
        fhTrain >>classLabel(i);
        for (int j= 0;j<x;j++)
            fhTrain>>DIRECT_A2D_ELEM(dataSet,i,j);
    }
    fhTrain.close();
}

normalizeDataset()

void AutoParticlePicking2::normalizeDataset	(	int	a,
		int	b
	)

Definition at line 1614 of file micrograph_automatic_picking2.cpp.

{

    double max,min;
    MultidimArray<double> maxA;
    MultidimArray<double> minA;

    maxA.resize(1,1,1,YSIZE(dataSet));
    minA.resize(1,1,1,YSIZE(dataSet));

    // Computing the maximum and minimum of each row
    for (size_t i=0;i<YSIZE(dataSet);i++)
    {
        max=min=DIRECT_A2D_ELEM(dataSet,i,0);
        for (size_t j=1;j<XSIZE(dataSet);j++)
        {
            if (max<DIRECT_A2D_ELEM(dataSet,i,j))
                max=DIRECT_A2D_ELEM(dataSet,i,j);
            if (min>DIRECT_A2D_ELEM(dataSet,i,j))
                min=DIRECT_A2D_ELEM(dataSet,i,j);
        }
        DIRECT_A1D_ELEM(maxA,i)=max;
        DIRECT_A1D_ELEM(minA,i)=min;
    }
    // Normalizing the dataset according to the max and mean
    for (size_t i=0;i<YSIZE(dataSet);i++)
    {
        max=DIRECT_A1D_ELEM(maxA,i);
        min=DIRECT_A1D_ELEM(minA,i);
        for (size_t j=0;j<XSIZE(dataSet);j++)
            DIRECT_A2D_ELEM(dataSet,i,j)=a+((b-a)*((DIRECT_A2D_ELEM(dataSet,i,j)-min)/(max-min)));
    }
}

PCAProject()

double AutoParticlePicking2::PCAProject	(	MultidimArray< double > &	pcaBasis,
		MultidimArray< double > &	vec
	)

Project a vector on one pca basis.

Definition at line 1101 of file micrograph_automatic_picking2.cpp.

{
    double dotProduct=0;
    const double *ptr2 = &DIRECT_A1D_ELEM(pcaBasis,0);
    const double *ptr3 = &DIRECT_A1D_ELEM(vec,0);
    size_t iBlockMax = XSIZE(pcaBasis) / 4;
    for (size_t i = 0; i < iBlockMax; i++)
    {
        dotProduct += (*ptr2++) * (*ptr3++);
        dotProduct += (*ptr2++) * (*ptr3++);
        dotProduct += (*ptr2++) * (*ptr3++);
        dotProduct += (*ptr2++) * (*ptr3++);
    }
    for (size_t i = iBlockMax * 4; i < XSIZE(pcaBasis); ++i)
        dotProduct += (*ptr2++) * (*ptr3++);
    return dotProduct;
}

polarCorrelation()

void AutoParticlePicking2::polarCorrelation	(	const MultidimArray< std::complex< double > > &	fourierPolarStack,
		MultidimArray< double > &	IpolarCorr
	)

Calculate the correlation of different polar channels.

Definition at line 1005 of file micrograph_automatic_picking2.cpp.

{
    int nF = NSIZE(fourierPolarStack);
    CorrelationAux aux;

    for (int n=0; n<nF;++n)
        correlationBetweenPolarChannels(n,n,n,fourierPolarStack,IpolarCorr,aux);
    for (int i=0; i<(filter_num-corr_num);i++)
        for (int j=1;j<=corr_num;j++)
            correlationBetweenPolarChannels(i,i+j,nF++,fourierPolarStack,IpolarCorr,aux);
}

readMic()

void AutoParticlePicking2::readMic	(	const FileName &	fn_micrograph,
		int	keepPrev
	)

Read micrograph from the file.

Definition at line 102 of file micrograph_automatic_picking2.cpp.

{
    if (keepPrev)
    {
        mPrev=m;
        microImagePrev=microImage;
        micrographStackPre=micrographStack;
    }
    m.open_micrograph(fn_micrograph);
    microImage.read(fn_micrograph);
    // Resize the Micrograph
    selfScaleToSizeFourier((int)((m.Ydim)*scaleRate),
                           (int)((m.Xdim)*scaleRate),
                           microImage(),2);

    m.point1.x=-1;
    filterBankGenerator();
    micrographStack()=filterBankStack;
    filterBankStack.clear();

    if (!keepPrev)
    {
        mPrev=m;
        microImagePrev=microImage;
        micrographStackPre=micrographStack;
    }
}

readMicrograph()

void AutoParticlePicking2::readMicrograph

(

)

Read the micrograph in memory.

readNextMic()

int AutoParticlePicking2::readNextMic

(

FileName &

fnmicrograph

)

Definition at line 827 of file micrograph_automatic_picking2.cpp.

{
    FileName currentMic;
    size_t lastObjId = micList.size();
    for (size_t i=0;i<micList.size();i++)
    {
        micList[i].getValue(MDL_MICROGRAPH,currentMic);
        if (i==lastObjId-1)
            return 0;
        if (!strcmp(currentMic.c_str(),fnmicrograph.c_str()))
        {
            micList[i+1].getValue(MDL_MICROGRAPH,currentMic);
            fnmicrograph=currentMic;
            return 1;
        }
    }
    return 1;
}

readParams()

void AutoParticlePicking2::readParams

(

XmippProgram *

program

)

Read the parmaeters of the main program.

Definition at line 1766 of file micrograph_automatic_picking2.cpp.

{
    fn_micrograph = program->getParam("-i");
    particle_size = program->getIntParam("--particleSize");
    NPCA = program->getIntParam("--NPCA");
    filter_num = program->getIntParam("--filter_num");
    corr_num = program->getIntParam("--NCORR");
    Nthreads = program->getIntParam("--thr");
    fast = program->checkParam("--fast");
    proc_prec = program->getIntParam("--autoPercent");
}

saveAutoParticles() [1/2]

void AutoParticlePicking2::saveAutoParticles

(

MetaData &

md

)

Definition at line 1552 of file micrograph_automatic_picking2.cpp.

{
    size_t nmax=auto_candidates.size();
    for (size_t n=0;n<nmax;++n)
    {
        const Particle2 &p=auto_candidates[n];
        if (p.cost>0 && p.status==1)
        {
            size_t id=md.addObject();
            md.setValue(MDL_XCOOR,int(p.x*(1.0/scaleRate)),id);
            md.setValue(MDL_YCOOR,int(p.y*(1.0/scaleRate)),id);
            md.setValue(MDL_COST, p.cost,id);
            md.setValue(MDL_ENABLED,1,id);
        }
    }
}

saveAutoParticles() [2/2]

void AutoParticlePicking2::saveAutoParticles

(

std::vector< MDRowSql > &

md

)

Definition at line 1569 of file micrograph_automatic_picking2.cpp.

{
    size_t nmax=auto_candidates.size();
    MDRowSql row;
    for (size_t n=0;n<nmax;++n)
    {
        const Particle2 &p=auto_candidates[n];
        if (p.cost>0 && p.status==1)
        {
            row.setValue(MDL_XCOOR,int(p.x*(1.0/scaleRate)));
            row.setValue(MDL_YCOOR,int(p.y*(1.0/scaleRate)));
            row.setValue(MDL_COST, p.cost);
            row.setValue(MDL_ENABLED,1);
            md.push_back(row);
        }
    }
}

savePCAModel()

void AutoParticlePicking2::savePCAModel

(

const FileName &

fn

)

Save the PCA basis and average for each channel.

Definition at line 1531 of file micrograph_automatic_picking2.cpp.

{
    FileName fnPcaModel=fn_root+"_pca_model.stk";
    Image<double> II;
    MultidimArray<double> avg;

    avg=pcaAnalyzer.avg;
    avg.resize(1,1,NangSteps,NRsteps);
    II()=avg;
    II.write(fnPcaModel,ALL_IMAGES,true, WRITE_APPEND);
    for (int i=0; i<NPCA;i++)
    {
        MultidimArray<double> pcaBasis;
        pcaBasis=pcaAnalyzer.PCAbasis[i];
        pcaBasis.resize(1,1,NangSteps,NRsteps);
        II()=pcaBasis;
        II.write(fnPcaModel,ALL_IMAGES,true,WRITE_APPEND);
    }
}

saveTrainingSet() [1/2]

void AutoParticlePicking2::saveTrainingSet

(

)

Definition at line 525 of file micrograph_automatic_picking2.cpp.

{
    std::ofstream fhTrain;
    fhTrain.open(fnVector.c_str());
    fhTrain<<YSIZE(dataSet)<< " "<< XSIZE(dataSet)<< std::endl;
    for (size_t i=0;i<YSIZE(dataSet);i++)
    {
        fhTrain<<classLabel(i)<< std::endl;
        for (size_t j=0;j<XSIZE(dataSet);j++)
            fhTrain<<DIRECT_A2D_ELEM(dataSet,i,j)<<" ";
        fhTrain<<std::endl;
    }
    fhTrain.close();
}

saveTrainingSet() [2/2]

void AutoParticlePicking2::saveTrainingSet

(

const FileName &

fn_root

)

Save training set into memory.

Definition at line 1486 of file micrograph_automatic_picking2.cpp.

{
    double max,min;
    int a=0,b=1;
    MultidimArray<double> maxA,minA;
    std::ofstream fhTrain;

    maxA.resize(1,1,1,YSIZE(dataSet));
    minA.resize(1,1,1,YSIZE(dataSet));

    dataSetNormal.resize(NSIZE(dataSet), ZSIZE(dataSet), YSIZE(dataSet), XSIZE(dataSet));

    // Computing the maximum and minimum of each row
    for (size_t i=0;i<YSIZE(dataSet);i++)
    {
        max=min=DIRECT_A2D_ELEM(dataSet,i,0);
        for (size_t j=1;j<XSIZE(dataSet);j++)
        {
            if (max<DIRECT_A2D_ELEM(dataSet,i,j))
                max=DIRECT_A2D_ELEM(dataSet,i,j);
            if (min>DIRECT_A2D_ELEM(dataSet,i,j))
                min=DIRECT_A2D_ELEM(dataSet,i,j);
        }
        DIRECT_A1D_ELEM(maxA,i)=max;
        DIRECT_A1D_ELEM(minA,i)=min;
    }

    fhTrain.open(fn.c_str());
    fhTrain<<YSIZE(dataSet)<< " "<< XSIZE(dataSet)<< std::endl;
    // Normalizing the dataset according to the max and mean
    for (size_t i=0;i<YSIZE(dataSet);i++)
    {
        fhTrain<<classLabel(i)<< std::endl;
        max=DIRECT_A1D_ELEM(maxA,i);
        min=DIRECT_A1D_ELEM(minA,i);
        for (size_t j=0;j<XSIZE(dataSet);j++)
        {
            fhTrain<<DIRECT_A2D_ELEM(dataSet,i,j)<<" ";
            DIRECT_A2D_ELEM(dataSetNormal,i,j)=a+((b-a)*((DIRECT_A2D_ELEM(dataSet,i,j)-min)/(max-min)));
        }
        fhTrain<<std::endl;
    }
    fhTrain.close();
}

setSize()

void AutoParticlePicking2::setSize

(

int

pSize

)

Definition at line 92 of file micrograph_automatic_picking2.cpp.

{
    double t=std::max(0.25,50.0/pSize);
    scaleRate=std::min(1.0,t);
    particle_radius=(int)((pSize*scaleRate)*0.5);
    particle_size=particle_radius * 2;
    NRsteps=particle_size/2-3;
}

train()

void AutoParticlePicking2::train	(	const std::vector< MDRowSql > &	MD,
		bool	corrFlag,
		int	x,
		int	y,
		int	width,
		int	height
	)

Definition at line 456 of file micrograph_automatic_picking2.cpp.

{
    if (width!=0)
    {
        // Scale the specified region in the last micrograph to fit to the scaled one
        x*=scaleRate;
        y*=scaleRate;
        width*=scaleRate;
        height*=scaleRate;
        p1.x=x;
        p1.y=y;
        p2.x=x+width;
        p2.y=y+height;
    }
    //  Check if we are not in correcting mode
    if (!corrFlag)
    {
        if (fnPCAModel.exists())
        {
            // First delete are related files
            fnPCAModel.deleteFile();
            fnAvgModel.deleteFile();
            fnPCARotModel.deleteFile();
            fnVector.deleteFile();

            //Second reset all the arrays
            pcaModel.clear();
            pcaRotModel.clear();
            particleAvg.clear();
            dataSet.clear();
            classLabel.clear();
        }
        std::cout << "Read the data for PCA, Rot PCA, Average ..." << std::endl;
        // Read the data for PCA, Rot PCA, Average
        particleAvg.initZeros(particle_size+1,particle_size+1);
        particleAvg.setXmippOrigin();
        batchBuildInvariant(MD);
        trainPCA(fn_model);
        trainRotPCA(fnAvgModel,fnPCARotModel.removeAllExtensions());
        Image<double> II;
        II.read(fnPCAModel);
        pcaModel=II();
        std::cout << "Read rotational PCA model ..." << std::endl;
        // Read rotational PCA model
        II.read(fnPCARotModel);
        pcaRotModel=II();
        // Read the average of the particles for convolution
        II.read(fnAvgModel);
        particleAvg=II();
    }
    if (corrFlag)
    {
        buildInvariant(MD);
        dataSet.clear();
        classLabel.clear();
        loadTrainingSet(fnVector);
        add2Dataset(fnInvariant+"_Positive.stk",fnParticles+"_Positive.stk",1);
        add2Dataset(fnInvariant+"_Negative.stk",fnParticles+"_Negative.stk",2);
    }
    else
    {
        add2Dataset(fnInvariant+"_Positive.stk",fnParticles+"_Positive.stk",1);
        add2Dataset(fnInvariant+"_Negative.stk",fnParticles+"_Negative.stk",2);
        saveTrainingSet(fnVector);
        normalizeDataset(0,1);
        trainSVM(fnSVMModel,1);
    }
}

trainPCA() [1/2]

void AutoParticlePicking2::trainPCA

(

)

Definition at line 340 of file micrograph_automatic_picking2.cpp.

{
    MultidimArray<float> pcaVec;
    MultidimArray<double> pcaVecD;
    MultidimArray<double> avg;
    Image<double> II;

    int steps=NSIZE(positiveInvariatnStack)/num_correlation;
    pcaModel.resize((NPCA+1)*num_correlation, 1, NangSteps, NRsteps);

    // Read the channel correlation one by one and obtain the basis for them.
    for (int i=0;i<num_correlation;i++)
    {
        for (int j=0;j<steps;j++)
        {
            pcaVecD.resize(1 , NangSteps, NRsteps);
            positiveInvariatnStack.getImage(j*num_correlation+i,pcaVecD);
            pcaVecD.resize(1, 1, XSIZE(pcaVecD)*YSIZE(pcaVecD));
            pcaVec.resize(pcaVecD);
            FOR_ALL_DIRECT_ELEMENTS_IN_ARRAY1D(pcaVecD)
            DIRECT_A1D_ELEM(pcaVec,i)=(float)DIRECT_A1D_ELEM(pcaVecD,i);
            pcaAnalyzer.addVector(pcaVec);
        }
        pcaAnalyzer.subtractAvg();
        pcaAnalyzer.learnPCABasis(NPCA,10);
        avg=pcaAnalyzer.avg;
        avg.resize(1, NangSteps, NRsteps);
        avg.getImage(0, pcaModel, i*(NPCA+1));
        for (int k=0; k<NPCA;k++)
        {
            MultidimArray<double> pcaBasis;
            pcaBasis=pcaAnalyzer.PCAbasis[k];
            pcaBasis.resize(1, NangSteps, NRsteps);
            pcaBasis.getImage(0, pcaModel, i*(NPCA+1)+k+1);
        }
        pcaAnalyzer.clear();
    }
    II()=pcaModel;
    II.write(fnPCAModel,ALL_IMAGES,true,WRITE_OVERWRITE);
    trainRotPCA(fnAvgModel,fnPCARotModel.removeAllExtensions());
    II.read(fnPCARotModel);
    pcaRotModel = II();
}

trainPCA() [2/2]

void AutoParticlePicking2::trainPCA

(

const FileName &

fnPositiveFeat

)

Definition at line 1120 of file micrograph_automatic_picking2.cpp.

{
    ImageGeneric positiveInvariant;
    MultidimArray<float> pcaVec;
    ArrayDim aDim;

    FileName fnPositiveInvariatn=fnPositiveFeat+"_invariant_Positive.stk";
    positiveInvariant.read(fnPositiveInvariatn,HEADER);
    positiveInvariant.getDimensions(aDim);
    int steps=aDim.ndim/num_correlation;
    // Read the channel correlation one by one and obtain the basis for them.
    for (int i=1;i<=num_correlation;i++)
    {
        for (int j=0;j<steps;j++)
        {
            positiveInvariant.readMapped(fnPositiveInvariatn,j*num_correlation+i);
            positiveInvariant().getImage(pcaVec);
            pcaVec.resize(1,1,1,XSIZE(pcaVec)*YSIZE(pcaVec));
            pcaAnalyzer.addVector(pcaVec);
        }
        pcaAnalyzer.subtractAvg();
        pcaAnalyzer.learnPCABasis(NPCA,10);
        savePCAModel(fnPositiveFeat);
        pcaAnalyzer.clear();
    }
}

trainRotPCA()

void AutoParticlePicking2::trainRotPCA	(	const FileName &	fnAvgModel,
		const FileName &	fnPCARotModel
	)

Definition at line 1147 of file micrograph_automatic_picking2.cpp.

{
    // just set the parameters and call the run method of the object
    // in order to obtain the rotational PCA basis.
    rotPcaAnalyzer.fnIn=fnAvgModel;
    rotPcaAnalyzer.fnRoot=fnPCARotModel;
    rotPcaAnalyzer.psi_step=2;
    rotPcaAnalyzer.Nthreads=4;
    rotPcaAnalyzer.Neigen=20;
    rotPcaAnalyzer.shift_step=1;
    rotPcaAnalyzer.Nits=2;
    rotPcaAnalyzer.maxNimgs=-1;
    rotPcaAnalyzer.max_shift_change=0;
    rotPcaAnalyzer.run();
}

trainSVM()

void AutoParticlePicking2::trainSVM	(	const FileName &	fnModel,
		int	numClassifier
	)

Definition at line 1163 of file micrograph_automatic_picking2.cpp.

{

    if (numClassifier==1)
    {
        classifier.SVMTrain(dataSetNormal,classLabel);
        classifier.SaveModel(fnModel);
    }
    else
    {
        classifier2.SVMTrain(dataSet1,classLabel1);
        classifier2.SaveModel(fnModel);
    }
}

Member Data Documentation

accepted_particles

std::vector<Particle2> AutoParticlePicking2::accepted_particles

Definition at line 80 of file micrograph_automatic_picking2.h.

auto_candidates

std::vector<Particle2> AutoParticlePicking2::auto_candidates

Definition at line 78 of file micrograph_automatic_picking2.h.

autoFeatVec

MultidimArray<double> AutoParticlePicking2::autoFeatVec

Definition at line 89 of file micrograph_automatic_picking2.h.

classifier

SVMClassifier AutoParticlePicking2::classifier

Definition at line 69 of file micrograph_automatic_picking2.h.

classifier2

SVMClassifier AutoParticlePicking2::classifier2

Definition at line 69 of file micrograph_automatic_picking2.h.

classLabel

MultidimArray<double> AutoParticlePicking2::classLabel

Definition at line 90 of file micrograph_automatic_picking2.h.

classLabel1

MultidimArray<double> AutoParticlePicking2::classLabel1

Definition at line 91 of file micrograph_automatic_picking2.h.

convolveRes

MultidimArray<double> AutoParticlePicking2::convolveRes

Definition at line 88 of file micrograph_automatic_picking2.h.

corr_num

int AutoParticlePicking2::corr_num

Definition at line 66 of file micrograph_automatic_picking2.h.

dataSet

MultidimArray<double> AutoParticlePicking2::dataSet

Definition at line 90 of file micrograph_automatic_picking2.h.

dataSet1

MultidimArray<double> AutoParticlePicking2::dataSet1

Definition at line 90 of file micrograph_automatic_picking2.h.

dataSetNormal

MultidimArray<double> AutoParticlePicking2::dataSetNormal

Definition at line 91 of file micrograph_automatic_picking2.h.

fast

int AutoParticlePicking2::fast

Definition at line 67 of file micrograph_automatic_picking2.h.

filter_num

int AutoParticlePicking2::filter_num

Definition at line 66 of file micrograph_automatic_picking2.h.

filterBankStack

MultidimArray<double> AutoParticlePicking2::filterBankStack

Definition at line 88 of file micrograph_automatic_picking2.h.

fn_micrograph

FileName AutoParticlePicking2::fn_micrograph

Definition at line 84 of file micrograph_automatic_picking2.h.

fn_model

FileName AutoParticlePicking2::fn_model

Definition at line 84 of file micrograph_automatic_picking2.h.

fnAvgModel

FileName AutoParticlePicking2::fnAvgModel

Definition at line 84 of file micrograph_automatic_picking2.h.

fnInvariant

FileName AutoParticlePicking2::fnInvariant

Definition at line 85 of file micrograph_automatic_picking2.h.

fnParticles

FileName AutoParticlePicking2::fnParticles

Definition at line 85 of file micrograph_automatic_picking2.h.

fnPCAModel

FileName AutoParticlePicking2::fnPCAModel

Definition at line 84 of file micrograph_automatic_picking2.h.

fnPCARotModel

FileName AutoParticlePicking2::fnPCARotModel

Definition at line 84 of file micrograph_automatic_picking2.h.

fnSVMModel

FileName AutoParticlePicking2::fnSVMModel

Definition at line 85 of file micrograph_automatic_picking2.h.

fnSVMModel2

FileName AutoParticlePicking2::fnSVMModel2

Definition at line 85 of file micrograph_automatic_picking2.h.

fnVector

FileName AutoParticlePicking2::fnVector

Definition at line 85 of file micrograph_automatic_picking2.h.

labelSet

MultidimArray<double> AutoParticlePicking2::labelSet

Definition at line 91 of file micrograph_automatic_picking2.h.

m

Micrograph AutoParticlePicking2::m

Definition at line 74 of file micrograph_automatic_picking2.h.

micList

std::vector<MDRowSql> AutoParticlePicking2::micList

Definition at line 82 of file micrograph_automatic_picking2.h.

micrographStack

Image<double> AutoParticlePicking2::micrographStack

Definition at line 76 of file micrograph_automatic_picking2.h.

micrographStackPre

Image<double> AutoParticlePicking2::micrographStackPre

Definition at line 76 of file micrograph_automatic_picking2.h.

microImage

Image<double> AutoParticlePicking2::microImage

Definition at line 76 of file micrograph_automatic_picking2.h.

microImagePrev

Image<double> AutoParticlePicking2::microImagePrev

Definition at line 76 of file micrograph_automatic_picking2.h.

mPrev

Micrograph AutoParticlePicking2::mPrev

Definition at line 74 of file micrograph_automatic_picking2.h.

NangSteps

const int AutoParticlePicking2::NangSteps =120

static

Definition at line 65 of file micrograph_automatic_picking2.h.

negative_candidates

std::vector<Particle2> AutoParticlePicking2::negative_candidates

Definition at line 81 of file micrograph_automatic_picking2.h.

negativeInvariatnStack

MultidimArray<double> AutoParticlePicking2::negativeInvariatnStack

Definition at line 89 of file micrograph_automatic_picking2.h.

negativeParticleStack

MultidimArray<double> AutoParticlePicking2::negativeParticleStack

Definition at line 88 of file micrograph_automatic_picking2.h.

NPCA

int AutoParticlePicking2::NPCA

Definition at line 66 of file micrograph_automatic_picking2.h.

NRPCA

int AutoParticlePicking2::NRPCA

Definition at line 66 of file micrograph_automatic_picking2.h.

NRsteps

int AutoParticlePicking2::NRsteps

Definition at line 67 of file micrograph_automatic_picking2.h.

Nthreads

int AutoParticlePicking2::Nthreads

Definition at line 67 of file micrograph_automatic_picking2.h.

num_correlation

int AutoParticlePicking2::num_correlation

Definition at line 67 of file micrograph_automatic_picking2.h.

num_features

int AutoParticlePicking2::num_features

Definition at line 67 of file micrograph_automatic_picking2.h.

p1

Micrograph::Point AutoParticlePicking2::p1

Definition at line 72 of file micrograph_automatic_picking2.h.

p2

Micrograph::Point AutoParticlePicking2::p2

Definition at line 72 of file micrograph_automatic_picking2.h.

particle_radius

int AutoParticlePicking2::particle_radius

Definition at line 66 of file micrograph_automatic_picking2.h.

particle_size

int AutoParticlePicking2::particle_size

Definition at line 66 of file micrograph_automatic_picking2.h.

particleAvg

MultidimArray<double> AutoParticlePicking2::particleAvg

Definition at line 90 of file micrograph_automatic_picking2.h.

pcaAnalyzer

PCAMahalanobisAnalyzer AutoParticlePicking2::pcaAnalyzer

Definition at line 70 of file micrograph_automatic_picking2.h.

pcaModel

MultidimArray<double> AutoParticlePicking2::pcaModel

Definition at line 90 of file micrograph_automatic_picking2.h.

pcaRotModel

MultidimArray<double> AutoParticlePicking2::pcaRotModel

Definition at line 90 of file micrograph_automatic_picking2.h.

positiveInvariatnStack

MultidimArray<double> AutoParticlePicking2::positiveInvariatnStack

Definition at line 89 of file micrograph_automatic_picking2.h.

positiveParticleStack

MultidimArray<double> AutoParticlePicking2::positiveParticleStack

Definition at line 88 of file micrograph_automatic_picking2.h.

proc_prec

int AutoParticlePicking2::proc_prec

Definition at line 66 of file micrograph_automatic_picking2.h.

rejected_particles

std::vector<Particle2> AutoParticlePicking2::rejected_particles

Definition at line 79 of file micrograph_automatic_picking2.h.

rotPcaAnalyzer

ProgImageRotationalPCA AutoParticlePicking2::rotPcaAnalyzer

Definition at line 71 of file micrograph_automatic_picking2.h.

scaleRate

double AutoParticlePicking2::scaleRate

Definition at line 87 of file micrograph_automatic_picking2.h.

thread

FeaturesThread* AutoParticlePicking2::thread

Definition at line 73 of file micrograph_automatic_picking2.h.

---

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

• xmipp/libraries/reconstruction/micrograph_automatic_picking2.h
• xmipp/libraries/reconstruction/micrograph_automatic_picking2.cpp