// Show a complex array ---------------------------------------------------
std::ostream& operator<<(std::ostream& ostrm,
const MultidimArray< Complex >& v)
{
if (v.xdim == 0)
ostrm << "NULL MultidimArray\n";
else
ostrm << std::endl;
for (int l = 0; l < NSIZE(v); l++)
{
if (NSIZE(v)>1) ostrm << "Image No. " << l << std::endl;
for (int k = STARTINGZ(v); k <= FINISHINGZ(v); k++)
{
if (ZSIZE(v) > 1) ostrm << "Slice No. " << k << std::endl;
for (int i = STARTINGY(v); i <= FINISHINGY(v); i++)
{
for (int j = STARTINGX(v); j <= FINISHINGX(v); j++)
ostrm << "(" << A3D_ELEM(v, k, i, j).real << "," << A3D_ELEM(v, k, i, j).imag << ")" << ' ';
ostrm << std::endl;
}
}
}
return ostrm;
}
/* Footprint of a blob ----------------------------------------------------- */
void footprint_blob(
ImageOver &blobprint, // blob foot_print table
const struct blobtype &blob, // blob description
int istep, // number of foot-print samples per one sample
// on projection plane in u,v directions
int normalise) // set to 1 if you want normalise. Usually
// you may omit it and no normalisation is performed
{
// Resize output image and redefine the origin of it
int footmax = CEIL(blob.radius);
blobprint.init(-footmax, footmax, istep, -footmax, footmax, istep);
// Run for Imge class indexes
for (int i = STARTINGY(blobprint()); i <= FINISHINGY(blobprint()); i++)
for (int j = STARTINGX(blobprint()); j <= FINISHINGX(blobprint()); j++)
{
// Compute oversampled index and blob value
double vi, ui;
IMG2OVER(blobprint, i, j, vi, ui);
double r = sqrt(vi * vi + ui * ui);
IMGPIXEL(blobprint, i, j) = blob_proj(r, blob);
}
// Adjust the footprint structure
if (normalise)
blobprint() /= blobprint().sum();
}
//#define DEBUG
void normalize_tomography(MultidimArray<double> &I, double tilt, double &mui,
double &sigmai, bool tiltMask, bool tomography0,
double mu0, double sigma0)
{
// Tilt series are always 2D
I.checkDimension(2);
const int L=2;
// Build a mask using the tilt angle
I.setXmippOrigin();
MultidimArray<int> mask;
mask.initZeros(I);
int Xdimtilt=(int)XMIPP_MIN(FLOOR(0.5*(XSIZE(I)*cos(DEG2RAD(tilt)))),
0.5*(XSIZE(I)-(2*L+1)));
int N=0;
for (int i=STARTINGY(I); i<=FINISHINGY(I); i++)
for (int j=-Xdimtilt; j<=Xdimtilt;j++)
{
A2D_ELEM(mask,i,j)=1;
N++;
}
// Estimate the local variance
MultidimArray<double> localVariance;
localVariance.initZeros(I);
double meanVariance=0;
FOR_ALL_ELEMENTS_IN_ARRAY2D(I)
{
// Center a mask of size 5x5 and estimate the variance within the mask
double meanPiece=0, variancePiece=0;
double Npiece=0;
for (int ii=i-L; ii<=i+L; ii++)
{
if (INSIDEY(I,ii))
for (int jj=j-L; jj<=j+L; jj++)
{
if (INSIDEX(I,jj))
{
double pixval=A2D_ELEM(I,ii,jj);
meanPiece+=pixval;
variancePiece+=pixval*pixval;
++Npiece;
}
}
}
meanPiece/=Npiece;
variancePiece=variancePiece/(Npiece-1)-
Npiece/(Npiece-1)*meanPiece*meanPiece;
A2D_ELEM(localVariance,i,j)=variancePiece;
meanVariance+=variancePiece;
}
meanVariance*=1.0/N;
// Test the hypothesis that the variance in this piece is
// the same as the variance in the whole image
double iFu=1/icdf_FSnedecor(4*L*L+4*L,N-1,0.975);
double iFl=1/icdf_FSnedecor(4*L*L+4*L,N-1,0.025);
double iMeanVariance=1.0/meanVariance;
FOR_ALL_ELEMENTS_IN_ARRAY2D(localVariance)
{
if (A2D_ELEM(localVariance,i,j)==0)
A2D_ELEM(mask,i,j)=-2;
if (A2D_ELEM(mask,i,j)==1)
{
double ratio=A2D_ELEM(localVariance,i,j)*iMeanVariance;
double thl=ratio*iFu;
double thu=ratio*iFl;
if (thl>1 || thu<1)
A2D_ELEM(mask,i,j)=-1;
}
}
#ifdef DEBUG
Image<double> save;
save()=I;
save.write("PPP.xmp");
save()=localVariance;
save.write("PPPLocalVariance.xmp");
Image<int> savemask;
savemask()=mask;
savemask.write("PPPmask.xmp");
#endif
// Compute the statistics again in the reduced mask
double avg, stddev, min, max;
computeStats_within_binary_mask(mask, I, min, max, avg, stddev);
double cosTilt=cos(DEG2RAD(tilt));
double iCosTilt=1.0/cosTilt;
if (tomography0)
{
double iadjustedStddev=1.0/(sigma0*cosTilt);
FOR_ALL_ELEMENTS_IN_ARRAY2D(I)
switch (A2D_ELEM(mask,i,j))
{
case -2:
A2D_ELEM(I,i,j)=0;
break;
case 0:
if (tiltMask)
A2D_ELEM(I,i,j)=0;
else
A2D_ELEM(I,i,j)=(A2D_ELEM(I,i,j)*iCosTilt-mu0)*iadjustedStddev;
break;
case -1:
case 1:
A2D_ELEM(I,i,j)=(A2D_ELEM(I,i,j)*iCosTilt-mu0)*iadjustedStddev;
break;
}
}
else
{
// Evaluate plane ----------------------------------------------------------
double evaluatePlane(double rot, double tilt,
const MultidimArray<double> *V, const MultidimArray<double> *Vmag,
double maxFreq, double planeWidth, int direction,
MultidimArray<double> *Vdraw=NULL,
bool setPos=false, double rotPos=0, double tiltPos=0)
{
if (rot<0 || rot>360 || tilt<-90 || tilt>90)
return 0;
Matrix2D<double> E, Einv;
Euler_angles2matrix(rot,tilt,0,E);
Einv=E.transpose();
if (setPos)
{
Matrix2D<double> Epos;
Euler_angles2matrix(rotPos,tiltPos,0,Epos);
double angle=acos(E(2,0)*Epos(2,0)+E(2,1)*Epos(2,1)+E(2,2)*Epos(2,2));
angle=RAD2DEG(angle);
if (fabs(angle)<20 || fabs(180-angle)<20)
return 0;
}
size_t N=XMIPP_MAX(XSIZE(*Vmag),YSIZE(*Vmag)/2);
N=XMIPP_MAX(N,ZSIZE(*Vmag)/2);
double df=0.5/N;
Matrix1D<double> freq(3), freqp(3);
Matrix1D<int> idx(3);
double sumNeg=0, sumPos=0;
int Nneg=0, Npos=0;
double maxFreq2=maxFreq*maxFreq;
int iPlaneWidth=(int)ceil(planeWidth);
for (double ix=0; ix<=N; ix++)
{
XX(freq)=ix*df;
double fx2=XX(freq)*XX(freq);
if (fx2>maxFreq2)
continue;
for (double iy=-(int)N; iy<=N; iy++)
{
YY(freq)=iy*df;
double fx2fy2=fx2+YY(freq)*YY(freq);
if (fx2fy2>maxFreq2)
continue;
for (int iz=-iPlaneWidth; iz<=iPlaneWidth; iz++)
{
if (iz==0 || ix==0 || iy==0)
continue;
// Frequency in the coordinate system of the plane
ZZ(freq)=iz*df;
// Frequency in the coordinate system of the volume
SPEED_UP_temps012;
M3x3_BY_V3x1(freqp,Einv,freq);
bool inverted=false;
if (XX(freqp)<0)
{
XX(freqp)=-XX(freqp);
YY(freqp)=-YY(freqp);
ZZ(freqp)=-ZZ(freqp);
inverted=true;
}
// Get the corresponding index
DIGFREQ2FFT_IDX(ZZ(freqp), ZSIZE(*V), ZZ(idx));
DIGFREQ2FFT_IDX(YY(freqp), YSIZE(*V), YY(idx));
DIGFREQ2FFT_IDX(XX(freqp), XSIZE(*V), XX(idx));
if (XX(idx) < STARTINGX(*Vmag) || XX(idx) > FINISHINGX(*Vmag) ||
YY(idx) < STARTINGY(*Vmag) || YY(idx) > FINISHINGY(*Vmag) ||
ZZ(idx) < STARTINGZ(*Vmag) || ZZ(idx) > FINISHINGZ(*Vmag))
continue;
// Make the corresponding sums
bool negativeSum;
if (direction==1)
negativeSum=iz<0;
else
negativeSum=iz>0;
double val=A3D_ELEM(*Vmag,ZZ(idx),YY(idx),XX(idx));
if ((negativeSum && !inverted) || (!negativeSum && inverted)) // XOR
{
sumNeg+=val;
Nneg++;
if (Vdraw!=NULL)
(*Vdraw)(idx)=2*direction*val;
}
else
{
sumPos+=val;
Npos++;
if (Vdraw!=NULL)
(*Vdraw)(idx)=1.0/2.0*direction*val;
}
}
}
}
if (fabs(Nneg-Npos)/(0.5*(Nneg+Npos))>0.5)
// If there is a difference of more than 50%
return 1e38;
if (Nneg!=0)
sumNeg/=Nneg;
else
return 1e38;
if (Npos!=0)
sumPos/=Npos;
else
return 1e38;
return -(sumPos-sumNeg);
}