CL3DClass Class Reference

#include <mpi_classify_CLTomo.h>

Collaboration diagram for CL3DClass:

Public Member Functions
	CL3DClass ()
	~CL3DClass ()
	CL3DClass (const CL3DClass &other)
	CL3DClass (const CL3DClass &&)=delete
CL3DClass &	operator= (const CL3DClass &other)
CL3DClass &	operator= (const CL3DClass &&)=delete
void	updateProjection (MultidimArray< double > &I, const CL3DAssignment &assigned, bool force=false)
void	transferUpdate ()
void	constructFourierMask (MultidimArray< double > &I)
void	constructFourierMaskFRM ()
void	fitBasic (MultidimArray< double > &I, CL3DAssignment &result)
void	lookForNeighbours (const std::vector< CL3DClass *> listP, int K)
	Look for K-nearest neighbours. More...

Public Attributes
MultidimArray< double >	P
MultidimArray< double >	Paux
MultidimArray< double >	bgMask
MultidimArray< std::complex< double > >	Pfourier
FourierTransformer	transformer
MultidimArray< std::complex< double > >	Ifourier
MultidimArray< double >	IfourierMag
MultidimArray< double >	IfourierMagSorted
MultidimArray< int >	IfourierMask
MultidimArray< int >	IfourierMaskFRM
PyObject *	pyIfourierMaskFRM =nullptr
MultidimArray< std::complex< double > >	Pupdate
MultidimArray< double >	PupdateMask
MultidimArray< double >	Iaux
std::vector< CL3DAssignment >	currentListImg
std::vector< CL3DAssignment >	nextListImg
std::vector< int >	neighboursIdx

Detailed Description

CL3DClass class

Definition at line 73 of file mpi_classify_CLTomo.h.

Constructor & Destructor Documentation

CL3DClass() [1/3]

CL3DClass::CL3DClass

(

)

Empty constructor

Definition at line 90 of file mpi_classify_CLTomo_prog.cpp.

{
    Paux.initZeros(prmCL3Dprog->Zdim, prmCL3Dprog->Ydim, prmCL3Dprog->Xdim);
    Paux.setXmippOrigin();
    transformer.setReal(Paux);
    //PupdateReal=Paux;
    Pupdate.initZeros(transformer.fFourier);
    PupdateMask.initZeros(Pupdate);
    pyIfourierMaskFRM=NULL;
    //weightSum=0;
}

~CL3DClass()

CL3DClass::~CL3DClass ( )

inline

Destructor

Definition at line 125 of file mpi_classify_CLTomo.h.

{}

CL3DClass() [2/3]

CL3DClass::CL3DClass

(

const CL3DClass &

other

)

Copy constructor

Definition at line 102 of file mpi_classify_CLTomo_prog.cpp.

{
    *this=other;
}

CL3DClass() [3/3]

CL3DClass::CL3DClass ( const CL3DClass &&  )

delete

Member Function Documentation

constructFourierMask()

void CL3DClass::constructFourierMask

(

MultidimArray< double > &

I

)

Construct Fourier mask

Definition at line 284 of file mpi_classify_CLTomo_prog.cpp.

{
    transformer.FourierTransform(I,Ifourier,false);

    FFT_magnitude(Ifourier,IfourierMag);
    IfourierMag.resize(1,1,1,MULTIDIM_SIZE(IfourierMag));
    IfourierMag.sort(IfourierMagSorted);
    double minMagnitude=A1D_ELEM(IfourierMagSorted,(int)(prmCL3Dprog->sparsity*XSIZE(IfourierMag)));

    IfourierMask.initZeros(Ifourier);
    for (size_t n=1; n<MULTIDIM_SIZE(Ifourier); ++n)
        if (DIRECT_MULTIDIM_ELEM(IfourierMag,n)>minMagnitude)
            DIRECT_MULTIDIM_ELEM(IfourierMask,n)=1;
}

constructFourierMaskFRM()

void CL3DClass::constructFourierMaskFRM

(

)

Construct the mask in the FRM convention

Definition at line 299 of file mpi_classify_CLTomo_prog.cpp.

{
    auto xdim=(int)(prmCL3Dprog->Xdim);
    auto xdim_2=(int)xdim/2;
    IfourierMaskFRM.initZeros(prmCL3Dprog->Xdim,prmCL3Dprog->Xdim,prmCL3Dprog->Xdim);
    IfourierMaskFRM.setXmippOrigin();
    FOR_ALL_ELEMENTS_IN_ARRAY3D(IfourierMask)
    if (A3D_ELEM(IfourierMask,k,i,j) && A3D_ELEM(prmCL3Dprog->maxFreqMask,k,i,j))
    {
        int kp=k, ip=i;
        if (k>xdim_2)
            kp-=xdim;
        if (i>xdim_2)
            ip-=xdim;
        A3D_ELEM(IfourierMaskFRM,j,ip,kp)=A3D_ELEM(IfourierMaskFRM,-j,-ip,-kp)=1;
    }

    PyObject *pyMask=Python::convertToNumpy(IfourierMaskFRM);
    PyObject *arglist = Py_BuildValue("(Oi)", pyMask,0);
    if (pyIfourierMaskFRM!=NULL)
        Py_DECREF(pyIfourierMaskFRM);
    pyIfourierMaskFRM = PyObject_CallObject(prmCL3Dprog->wedgeClass, arglist);
    /*if (PyErr_Occurred()!=NULL)
        PyErr_Print();*/
    Py_DECREF(arglist);
    Py_DECREF(pyMask);
}

fitBasic()

void CL3DClass::fitBasic	(	MultidimArray< double > &	I,
		CL3DAssignment &	result
	)

Compute the fit of the input image with this node. The input image is rotationally and traslationally aligned (2 iterations), to make it fit with the node.

Definition at line 328 of file mpi_classify_CLTomo_prog.cpp.

{
#ifdef DEBUG
    Image<double> save2;
    save2()=I;
    save2.write("PPPfitBasicI0.xmp");
    save2()=P;
    save2.write("PPPfitBasicI1.xmp");
#endif

    if (currentListImg.size() == 0)
        return;

    Matrix2D<double> A;
    double frmScore;
    constructFourierMask(I);
    if (!prmCL3Dprog->dontAlign)
    {
        constructFourierMaskFRM();
        alignVolumesFRM(prmCL3Dprog->frmFunc, P, I, pyIfourierMaskFRM, result.rot, result.tilt, result.psi, result.shiftx, result.shifty, result.shiftz,
                frmScore,A,prmCL3Dprog->maxShift, prmCL3Dprog->maxFreq);
    }
    else
    {
        A.initIdentity(4);
        result.rot=result.tilt=result.psi=result.shiftx=result.shifty=result.shiftz=0.;
        frmScore=correlationIndex(P,I,&(prmCL3Dprog->mask.get_binary_mask()));
    }
    if (fabs(result.shiftx)>prmCL3Dprog->maxShiftX || fabs(result.shifty)>prmCL3Dprog->maxShiftY || fabs(result.shiftz)>prmCL3Dprog->maxShiftZ ||
        fabs(result.rot)>prmCL3Dprog->maxRot || fabs(result.tilt)>prmCL3Dprog->maxTilt || fabs(result.psi)>prmCL3Dprog->maxPsi)
        result.score=-1e38;
    else
    {
        if (prmCL3Dprog->dontAlign)
            Iaux=I;
        else
            applyGeometry(xmipp_transformation::LINEAR, Iaux, I, A, xmipp_transformation::IS_NOT_INV, xmipp_transformation::DONT_WRAP);
        apply_binary_mask(prmCL3Dprog->mask.get_binary_mask(),Iaux,I,0.0);
        constructFourierMask(I);
        result.score=frmScore;
    }

#ifdef DEBUG
    Image<double> save;
    save()=I;
    save.write("PPPfitBasicI2.xmp");
    save()=P-I;
    save.write("PPPfitBasicdiff.xmp");
    std::cout << result.rot << " " << result.tilt << " " << result.psi << " " << result.shiftx << " " << result.shifty << " " << result.shiftz << std::endl;
    std::cout << "final score=" << result.score << ". Press" << std::endl;
    char c;
    std::cin >> c;
#endif
}

lookForNeighbours()

void CL3DClass::lookForNeighbours	(	const std::vector< CL3DClass *>	listP,
		int	K
	)

Look for K-nearest neighbours.

Definition at line 386 of file mpi_classify_CLTomo_prog.cpp.

{
    int Q = listP.size();
    neighboursIdx.clear();
    if (K == Q)
    {
        // As many neighbours as codes
        for (int q = 0; q < Q; q++)
            neighboursIdx.push_back(q);
    }
    else
    {
        MultidimArray<double> distanceCode;
        distanceCode.initZeros(Q);
        CL3DAssignment assignment;
        MultidimArray<double> I;
        for (int q = 0; q < Q; q++)
        {
            if (listP[q] == this)
                distanceCode(q) = 1;
            else
            {
                I = listP[q]->P;
                fitBasic(I, assignment);
                A1D_ELEM(distanceCode,q) = 1-assignment.score;
            }
        }

        MultidimArray<int> idx;
        distanceCode.indexSort(idx);
        for (int k = 0; k < K; k++)
            neighboursIdx.push_back(idx(Q - k - 1) - 1);
    }
#ifdef DEBUG
    Image<double> save;
    save()=P;
    save.write("PPPthis.xmp");
    for (int k=0; k<K; k++)
    {
        save()=listP[neighboursIdx[k]]->P;
        save.write((std::string)"PPPneigh"+integerToString(k,1));
    }
    std::cout << "Neighbours saved. Press any key\n";
    char c;
    std::cin >> c;
#endif
}

operator=() [1/2]

CL3DClass & CL3DClass::operator=

(

const CL3DClass &

other

)

Assignment

Definition at line 107 of file mpi_classify_CLTomo_prog.cpp.

{
    if (this!=&other)
    {
        CL3DAssignment assignment;
        assignment.score = -1e38;
        updateProjection((MultidimArray<double> &)other.P,assignment);
        transferUpdate();

        currentListImg = other.currentListImg;
        neighboursIdx = other.neighboursIdx;
    }
    return *this;
}

operator=() [2/2]

CL3DClass& CL3DClass::operator= ( const CL3DClass &&  )

delete

transferUpdate()

void CL3DClass::transferUpdate

(

)

Transfer update

Definition at line 180 of file mpi_classify_CLTomo_prog.cpp.

{
    if (nextListImg.size() > 0)
    {
        // Take from Pupdate
        auto *ptrPupdate=(double*)&DIRECT_MULTIDIM_ELEM(Pupdate,0);
        FOR_ALL_DIRECT_ELEMENTS_IN_MULTIDIMARRAY(PupdateMask)
        {
            double maskVal=DIRECT_MULTIDIM_ELEM(PupdateMask,n);
            if (maskVal>0 && DIRECT_MULTIDIM_ELEM(prmCL3Dprog->maxFreqMask,n))
            {
                double iMask=1./maskVal;
                *ptrPupdate*=iMask;
                *(ptrPupdate+1)*=iMask;
            }
            else
            {
                *ptrPupdate=*(ptrPupdate+1)=0.;
            }
            ptrPupdate+=2;
        }
        Pfourier=Pupdate;

        transformer.inverseFourierTransform(Pupdate,Paux);
        //P=PupdateReal/weightSum;

        // Compact support in real space
#ifdef DEBUG
        Image<double> save;
        save()=Paux;
        save.write("PPPtransfer0.vol");
#endif

        double mean;
        detectBackground(Paux,bgMask,0.01,mean);
        if (bgMask.sum()<0.9*(XSIZE(Paux)-4)*(YSIZE(Paux)-4)*(ZSIZE(Paux)-4))
        {
            FOR_ALL_ELEMENTS_IN_ARRAY3D(Paux)
            if (A3D_ELEM(bgMask,k,i,j))
                A3D_ELEM(Paux,k,i,j) = 0;
            else if (k<=STARTINGZ(Paux)+2  || i<=STARTINGY(Paux)+2  || j<=STARTINGX(Paux)+2 ||
                     k>=FINISHINGZ(Paux)-2 || i>=FINISHINGY(Paux)-2 || j>=FINISHINGX(Paux)-2)
                A3D_ELEM(Paux,k,i,j) = 0;
        }

#ifdef DEBUG
        save()=Paux;
        save.write("PPPtransfer1.vol");
#endif
        // Compact support in wavelet space
        forceDWTSparsity(Paux,1.0-prmCL3Dprog->DWTsparsity);

#ifdef DEBUG
        save()=Paux;
        save.write("PPPtransfer2.vol");
#endif
        // Symmetrize
        symmetrizeVolume(prmCL3Dprog->SL,Paux,P,xmipp_transformation::WRAP);
#ifdef DEBUG
        save()=P;
        save.write("PPPtransfer3.vol");
#endif

        // Normalize and remove outside sphere
        P.statisticsAdjust(0., 1.);
        const MultidimArray<int> &mask=prmCL3Dprog->mask.get_binary_mask();
        FOR_ALL_DIRECT_ELEMENTS_IN_MULTIDIMARRAY(P)
        if (!DIRECT_MULTIDIM_ELEM(mask,n))
            DIRECT_MULTIDIM_ELEM(P,n) = 0;
        Pupdate.initZeros();
        //PupdateReal.initZeros();
        PupdateMask.initZeros();
        //weightSum=0;

#ifdef DEBUG
        save()=P;
        save.write("PPPtransfer4.vol");
#endif
        /* COSS: STILL TO PUT IN 3D
        // Make sure the image is centered
        centerImage(P,corrAux,rotAux);
        FOR_ALL_DIRECT_ELEMENTS_IN_MULTIDIMARRAY(P)
        if (!DIRECT_MULTIDIM_ELEM(mask,n))
            DIRECT_MULTIDIM_ELEM(P,n) = 0;
        */

        // Take the list of images
        currentListImg = nextListImg;
        nextListImg.clear();
    }
    else
    {
        currentListImg.clear();
        P.initZeros();
    }
#ifdef DEBUG
        P.printShape();
        std::cout << "Transfer finished. Press any key\n";
        char c;
        std::cin >> c;
#endif
}

updateProjection()

void CL3DClass::updateProjection	(	MultidimArray< double > &	I,
		const CL3DAssignment &	assigned,
		bool	force = false
	)

Update projection.

Definition at line 123 of file mpi_classify_CLTomo_prog.cpp.

{
    if ((fabs(assigned.score) <=1 && assigned.objId != BAD_OBJID && assigned.score>0) || force)
    {
        constructFourierMask(I);
        FOR_ALL_DIRECT_ELEMENTS_IN_MULTIDIMARRAY(Ifourier)
        if (DIRECT_MULTIDIM_ELEM(IfourierMask,n))
        {
            auto *ptrIfourier=(double*)&DIRECT_MULTIDIM_ELEM(Ifourier,n);
            auto *ptrPupdate=(double*)&DIRECT_MULTIDIM_ELEM(Pupdate,n);
            *ptrPupdate+=(*ptrIfourier)*assigned.score;
            *(ptrPupdate+1)+=(*(ptrIfourier+1))*assigned.score;
            DIRECT_MULTIDIM_ELEM(PupdateMask,n)+=assigned.score;
        }
        //PupdateReal+=I*assigned.score;
        //weightSum+=assigned.score;
        nextListImg.push_back(assigned);

#ifdef DEBUG
        Image<double> save;
        save()=I;
        save.write("PPPupdateI.vol");
        save()=PupdateReal;
        save.write("PPPupdateUpdateReal.vol");
        save()=P;
        if (MULTIDIM_SIZE(P)>0)
            save.write("PPPupdateP.vol");

        // Take from Pupdate
        MultidimArray< std::complex<double> > PfourierAux;
        PfourierAux=Pupdate;
        save().initZeros(I);
        double *ptrPupdate=(double*)&DIRECT_MULTIDIM_ELEM(PfourierAux,0);
        FOR_ALL_DIRECT_ELEMENTS_IN_MULTIDIMARRAY(PupdateMask)
        {
            double maskVal=DIRECT_MULTIDIM_ELEM(PupdateMask,n);
            if (maskVal>0)
            {
                double iMask=1./maskVal;
                *(ptrPupdate)*=iMask;
                *(ptrPupdate+1)*=iMask;
            }
            ptrPupdate+=2;
        }
        transformer.inverseFourierTransform(PfourierAux,save());
        save.write("PPPupdateUpdateFourier.vol");
        std::cout << "Updating. Press any key\n";
        char c;
        std::cin >> c;
#endif
    }
}

Member Data Documentation

bgMask

MultidimArray<double> CL3DClass::bgMask

Definition at line 76 of file mpi_classify_CLTomo.h.

currentListImg

std::vector<CL3DAssignment> CL3DClass::currentListImg

Definition at line 112 of file mpi_classify_CLTomo.h.

Iaux

MultidimArray<double> CL3DClass::Iaux

Definition at line 109 of file mpi_classify_CLTomo.h.

Ifourier

MultidimArray< std::complex<double> > CL3DClass::Ifourier

Definition at line 85 of file mpi_classify_CLTomo.h.

IfourierMag

MultidimArray<double> CL3DClass::IfourierMag

Definition at line 88 of file mpi_classify_CLTomo.h.

IfourierMagSorted

MultidimArray<double> CL3DClass::IfourierMagSorted

Definition at line 88 of file mpi_classify_CLTomo.h.

IfourierMask

MultidimArray<int> CL3DClass::IfourierMask

Definition at line 91 of file mpi_classify_CLTomo.h.

IfourierMaskFRM

MultidimArray<int> CL3DClass::IfourierMaskFRM

Definition at line 91 of file mpi_classify_CLTomo.h.

neighboursIdx

std::vector<int> CL3DClass::neighboursIdx

Definition at line 118 of file mpi_classify_CLTomo.h.

nextListImg

std::vector<CL3DAssignment> CL3DClass::nextListImg

Definition at line 115 of file mpi_classify_CLTomo.h.

P

MultidimArray<double> CL3DClass::P

Definition at line 76 of file mpi_classify_CLTomo.h.

Paux

MultidimArray<double> CL3DClass::Paux

Definition at line 76 of file mpi_classify_CLTomo.h.

Pfourier

MultidimArray< std::complex<double> > CL3DClass::Pfourier

Definition at line 79 of file mpi_classify_CLTomo.h.

Pupdate

MultidimArray< std::complex<double> > CL3DClass::Pupdate

Definition at line 97 of file mpi_classify_CLTomo.h.

PupdateMask

MultidimArray< double > CL3DClass::PupdateMask

Definition at line 106 of file mpi_classify_CLTomo.h.

pyIfourierMaskFRM

PyObject* CL3DClass::pyIfourierMaskFRM =nullptr

Definition at line 94 of file mpi_classify_CLTomo.h.

transformer

FourierTransformer CL3DClass::transformer

Definition at line 82 of file mpi_classify_CLTomo.h.

---

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

• xmipp/libraries/parallel/mpi_classify_CLTomo.h
• xmipp/libraries/parallel/mpi_classify_CLTomo_prog.cpp