// Compute fitness =========================================================
double ObjFunc_nma_alignment::eval(Vector X, int *nerror) {
int dim = global_nma_prog->numberOfModes;
for (int i = 0; i < dim; i++) {
global_nma_prog->trial(i) = X[i];
}
int pyramidLevelDisc = 1;
int pyramidLevelCont = (global_nma_prog->currentStage == 1) ? 1 : 0;
FileName fnRandom = global_nma_prog->createDeformedPDB(pyramidLevelCont);
const char * randStr = fnRandom.c_str();
if (global_nma_prog->currentStage == 1) {
global_nma_prog->performCompleteSearch(fnRandom, pyramidLevelDisc);
} else {
double rot, tilt, psi, xshift, yshift;
MetaData DF;
rot = global_nma_prog->bestStage1(
VEC_XSIZE(global_nma_prog->bestStage1) - 5);
tilt = global_nma_prog->bestStage1(
VEC_XSIZE(global_nma_prog->bestStage1) - 4);
psi = global_nma_prog->bestStage1(
VEC_XSIZE(global_nma_prog->bestStage1) - 3);
xshift = global_nma_prog->bestStage1(
VEC_XSIZE(global_nma_prog->bestStage1) - 2);
yshift = global_nma_prog->bestStage1(
VEC_XSIZE(global_nma_prog->bestStage1) - 1);
size_t objId = DF.addObject();
FileName fnDown = formatString("%s_downimg.xmp", randStr);
DF.setValue(MDL_IMAGE, fnDown, objId);
DF.setValue(MDL_ENABLED, 1, objId);
DF.setValue(MDL_ANGLE_ROT, rot, objId);
DF.setValue(MDL_ANGLE_TILT, tilt, objId);
DF.setValue(MDL_ANGLE_PSI, psi, objId);
DF.setValue(MDL_SHIFT_X, xshift, objId);
DF.setValue(MDL_SHIFT_Y, yshift, objId);
DF.write(formatString("%s_angledisc.xmd", randStr));
copyImage(global_nma_prog->currentImgName.c_str(), fnDown.c_str());
}
double fitness = global_nma_prog->performContinuousAssignment(fnRandom,
pyramidLevelCont);
runSystem("rm", formatString("-rf %s* &", randStr));
global_nma_prog->updateBestFit(fitness, dim);
return fitness;
}
// Continuous assignment ===================================================
double ProgNmaAlignment::performContinuousAssignment(const FileName &fnRandom,
int pyramidLevel) const {
// Perform alignment
const char * randStr = fnRandom.c_str();
String fnResults=formatString("%s_anglecont.xmd", randStr);
bool costSource=true;
String program = "xmipp_angular_continuous_assign";
String arguments =
formatString(
"-i %s_angledisc.xmd --ref %s_deformedPDB.vol -o %s --gaussian_Fourier %f --gaussian_Real %f --zerofreq_weight %f -v 0",
randStr, randStr, fnResults.c_str(), gaussian_DFT_sigma,
gaussian_Real_sigma, weight_zero_freq);
runSystem(program, arguments, false);
// Pick up results
MetaData DF(fnResults);
MDRow row;
DF.getRow(row, DF.firstObject());
row.getValue(MDL_ANGLE_ROT, trial(VEC_XSIZE(trial) - 5));
row.getValue(MDL_ANGLE_TILT, trial(VEC_XSIZE(trial) - 4));
row.getValue(MDL_ANGLE_PSI, trial(VEC_XSIZE(trial) - 3));
row.getValue(MDL_SHIFT_X, trial(VEC_XSIZE(trial) - 2));
trial(VEC_XSIZE(trial) - 2) *= pow(2.0, (double) pyramidLevel);
row.getValue(MDL_SHIFT_Y, trial(VEC_XSIZE(trial) - 1));
trial(VEC_XSIZE(trial) - 1) *= pow(2.0, (double) pyramidLevel);
double tempvar;
if (!costSource) {
row.getValue(MDL_MAXCC, tempvar);
tempvar = -tempvar;
} else
row.getValue(MDL_COST, tempvar);
return tempvar;
}
// Create deformed PDB =====================================================
FileName ProgNmaAlignment::createDeformedPDB(int pyramidLevel) const {
String program;
String arguments;
FileName fnRandom;
fnRandom.initUniqueName(nameTemplate,fnOutDir);
const char * randStr = fnRandom.c_str();
program = "xmipp_pdb_nma_deform";
arguments = formatString(
"--pdb %s -o %s_deformedPDB.pdb --nma %s --deformations ",
fnPDB.c_str(), randStr, fnModeList.c_str());
for (size_t i = 0; i < VEC_XSIZE(trial) - 5; ++i)
arguments += floatToString(trial(i)) + " ";
runSystem(program, arguments, false);
program = "xmipp_volume_from_pdb";
arguments = formatString(
"-i %s_deformedPDB.pdb --size %i --sampling %f -v 0", randStr,
imgSize, sampling_rate);
if (do_centerPDB)
arguments.append(" --centerPDB ");
if (useFixedGaussian) {
arguments.append(" --intensityColumn Bfactor --fixed_Gaussian ");
if (sigmaGaussian >= 0)
arguments += formatString("%f",sigmaGaussian);
}
//else
//arguments +=" --poor_Gaussian"; // Otherwise, a detailed conversion of the atoms takes too long in this context
progVolumeFromPDB->read(arguments);
progVolumeFromPDB->tryRun();
if (do_FilterPDBVol) {
program = "xmipp_transform_filter";
arguments = formatString(
"-i %s_deformedPDB.vol --sampling %f --fourier low_pass %f -v 0",
randStr, sampling_rate, cutoff_LPfilter);
runSystem(program, arguments, false);
}
if (pyramidLevel != 0) {
Image<double> I;
FileName fnDeformed = formatString("%s_deformedPDB.vol",randStr);
I.read(fnDeformed);
selfPyramidReduce(BSPLINE3, I(), pyramidLevel);
I.write(fnDeformed);
}
return fnRandom;
}
//This function generates the Zernike Polynomials. Please see: Efficient Cartesian representation of Zernike polynomials in computer memory
//SPIE Vol. 3190 pp. 382 to get more details about the implementation
void PolyZernikes::create(const Matrix1D<int> & coef)
{
Matrix2D<int> * fMatT;
int nMax=(int)VEC_XSIZE(coef);
for (int nZ = 0; nZ < nMax; ++nZ)
{
if (VEC_ELEM(coef,nZ) == 0)
{
fMatT = new Matrix2D<int>(1,1);
dMij(*fMatT,0,0)=0;
//*fMatT = 0;
}
else
{
// Note that the paper starts in n=1 and we start in n=0
int n = (size_t)ZERNIKE_ORDER(nZ);
int l = 2*nZ-n*(n+2);
int m = (n-l)/2;
Matrix2D<int> testM(n+1,n+1);
fMatT = new Matrix2D<int>(n+1,n+1);
int p = (l>0);
int q = ((n % 2 != 0) ? (abs(l)-1)/2 : (( l > 0 ) ? abs(l)/2-1 : abs(l)/2 ) );
l = abs(l); //We want the positive value of l
m = (n-l)/2;
for (int i = 0; i <= q; ++i)
{
int K1=binom(l,2*i+p);
for (int j = 0; j <= m; ++j)
{
int factor = ( (i+j)%2 ==0 ) ? 1 : -1 ;
int K2=factor * K1 * fact(n-j)/(fact(j)*fact(m-j)*fact(n-m-j));
for (int k = 0; k <= (m-j); ++k)
{
int ypow = 2 * (i+k) + p;
int xpow = n - 2 * (i+j+k) - p;
dMij(*fMatT,xpow,ypow) +=K2 * binom(m-j,k);
}
}
}
}
fMatV.push_back(*fMatT);
}
}
void ProgNmaAlignment::processImage(const FileName &fnImg,
const FileName &fnImgOut, const MDRow &rowIn, MDRow &rowOut) {
static size_t imageCounter = 0;
++imageCounter;
double rhoStart=trustradius_scale*250.;
double rhoEnd=trustradius_scale*50.;
int niter=10000;
ObjectiveFunction *of;
int dim = numberOfModes;
parameters.initZeros(dim + 5);
currentImgName = fnImg;
sprintf(nameTemplate, "_node%d_img%lu_XXXXXX", rangen, (long unsigned int)imageCounter);
trial.initZeros(dim + 5);
trial_best.initZeros(dim + 5);
fitness_min.initZeros(1);
fitness_min(0) = 1000000.0;
currentStage = 1;
#ifdef DEBUG
std::cerr << std::endl << "DEBUG: ===== Node: " << rangen
<<" processing image " << fnImg <<"(" << objId << ")"
<< " at stage: " << currentStage << std::endl;
#endif
of = new ObjFunc_nma_alignment(1, dim);
of->xStart.setSize(dim);
for (int i = 0; i < dim; i++)
of->xStart[i] = 0.;
#ifdef DEBUG
strcpy(of->name,("OF1_"+integerToString(rangen)).c_str());
of->setSaveFile();
#endif
CONDOR(rhoStart, rhoEnd, niter, of);
#ifdef DEBUG
of->printStats();
FILE *ff = fopen(("res1_"+integerToString(rangen)+".xmd").c_str(),"w");
fprintf(ff,"%s & %i & %i & (%i) & %e \\\\\n", of->name, of->dim(), of->getNFE(), of->getNFE2(), of->valueBest);
fclose(ff);
#endif
bestStage1 = trial = parameters = trial_best;
delete of;
currentStage = 2;
#ifdef DEBUG
std::cerr << std::endl << "DEBUG: ===== Node: " << rangen
<<" processing image " << fnImg <<"(" << objId << ")"
<< " at stage: " << currentStage << std::endl;
#endif
fitness_min(0) = 1000000.0;
of = new ObjFunc_nma_alignment(1, dim);
of->xStart.setSize(dim);
for (int i = 0; i < dim; i++)
of->xStart[i] = parameters(i);
#ifdef DEBUG
strcpy(of->name,("OF2_"+integerToString(rangen)).c_str());
of->setSaveFile();
#endif
rhoStart=trustradius_scale*50.-1., rhoEnd=0.5;
CONDOR(rhoStart, rhoEnd, niter, of);
#ifdef DEBUG
of->printStats();
ff=fopen(("res2_"+integerToString(rangen)+".xmd").c_str(),"w");
fprintf(ff,"%s & %i & %i & (%i) & %e \\\\\n", of->name, of->dim(), of->getNFE(), of->getNFE2(), of->valueBest);
fclose(ff);
#endif
#ifdef DEBUG
std::cout << "Best fitness = " << fitness << std::endl;
for (int i=0; i<dim; i++)
{
std::cout << "Best deformations = " << dd[i] << std::endl;
}
#endif
trial = trial_best;
for (int i = dim; i < dim + 5; i++) {
parameters(i - dim) = trial_best(i);
}
for (int i = 0; i < dim; i++) {
parameters(5 + i) = trial_best(i);
}
parameters.resize(VEC_XSIZE(parameters) + 1);
parameters(VEC_XSIZE(parameters) - 1) = fitness_min(0);
writeImageParameters(fnImg);
delete of;
}
SF_individual.setValue(MDL_IMAGE,fn_img_out,objId);
SF_individual.setValue(MDL_ANGLE_ROT,rot,objId);
SF_individual.setValue(MDL_ANGLE_TILT,tilt,objId);
SF_individual.setValue(MDL_ANGLE_PSI,psi,objId);
}
// Average over rings
Matrix1D<int> idx(2);
Matrix1D<double> freq(2);
STARTINGX(S2s) = STARTINGY(S2s) = 0;
STARTINGX(N2s) = STARTINGY(N2s) = 0;
STARTINGX(S2n) = STARTINGY(S2n) = 0;
STARTINGX(N2n) = STARTINGY(N2n) = 0;
double Xdim=XSIZE(S());
double maxwidx=VEC_XSIZE(S_S21D);
FOR_ALL_ELEMENTS_IN_ARRAY2D(S2s)
{
XX(idx) = j;
YY(idx) = i;
FFT_idx2digfreq(FFT_Is, idx, freq);
if (XX(freq) < 0)
continue;
// Look for the index corresponding to this frequency
double w = freq.module();
double widx = w * Xdim;
if (widx >= maxwidx)
continue;
int l0 = CEIL(widx - ring_width);
l0=XMIPP_MAX(0, l0);
void ProgVolumePCA::run()
{
show();
produce_side_info();
const MultidimArray<int> &imask=mask.imask;
size_t Nvoxels=imask.sum();
MultidimArray<float> v;
v.initZeros(Nvoxels);
// Add all volumes to the analyzer
FileName fnVol;
FOR_ALL_OBJECTS_IN_METADATA(mdVols)
{
mdVols.getValue(MDL_IMAGE,fnVol,__iter.objId);
V.read(fnVol);
// Construct vector
const MultidimArray<double> &mV=V();
size_t idx=0;
FOR_ALL_DIRECT_ELEMENTS_IN_MULTIDIMARRAY(mV)
{
if (DIRECT_MULTIDIM_ELEM(imask,n))
DIRECT_MULTIDIM_ELEM(v,idx++)=DIRECT_MULTIDIM_ELEM(mV,n);
}
analyzer.addVector(v);
}
// Construct PCA basis
analyzer.subtractAvg();
analyzer.learnPCABasis(NPCA,100);
// Project onto the PCA basis
Matrix2D<double> proj;
analyzer.projectOnPCABasis(proj);
std::vector<double> dimredProj;
dimredProj.resize(NPCA);
int i=0;
FOR_ALL_OBJECTS_IN_METADATA(mdVols)
{
memcpy(&dimredProj[0],&MAT_ELEM(proj,i,0),NPCA*sizeof(double));
mdVols.setValue(MDL_DIMRED,dimredProj,__iter.objId);
i++;
}
if (fnVolsOut!="")
mdVols.write(fnVolsOut);
else
mdVols.write(fnVols);
// Save the basis
const MultidimArray<double> &mV=V();
for (int i=NPCA-1; i>=0; --i)
{
V().initZeros();
size_t idx=0;
const MultidimArray<double> &mPCA=analyzer.PCAbasis[i];
FOR_ALL_DIRECT_ELEMENTS_IN_MULTIDIMARRAY(mV)
{
if (DIRECT_MULTIDIM_ELEM(imask,n))
DIRECT_MULTIDIM_ELEM(mV,n)=DIRECT_MULTIDIM_ELEM(mPCA,idx++);
}
if (fnBasis!="")
V.write(fnBasis,i+1,true,WRITE_OVERWRITE);
}
// Generate the PCA volumes
if (listOfPercentiles.size()>0 && fnOutStack!="" && fnAvgVol!="")
{
Image<double> Vavg;
if (fnAvgVol!="")
Vavg.read(fnAvgVol);
else
Vavg().initZeros(V());
Matrix1D<double> p;
proj.toVector(p);
Matrix1D<double> psorted=p.sort();
Image<double> Vpca;
Vpca()=Vavg();
createEmptyFile(fnOutStack,(int)XSIZE(Vavg()),(int)YSIZE(Vavg()),(int)ZSIZE(Vavg()),listOfPercentiles.size());
std::cout << "listOfPercentiles.size()=" << listOfPercentiles.size() << std::endl;
for (size_t i=0; i<listOfPercentiles.size(); i++)
{
int idx=(int)round(textToFloat(listOfPercentiles[i].c_str())/100.0*VEC_XSIZE(p));
std::cout << "Percentile " << listOfPercentiles[i] << " -> idx=" << idx << " p(idx)=" << psorted(idx) << std::endl;
Vpca()+=psorted(idx)*V();
Vpca.write(fnOutStack,i+1,true,WRITE_REPLACE);
}
}
}
