/* Do inference ------------------------------------------------------------ */
int NaiveBayes::doInference(const MultidimArray<double> &newFeatures, double &cost,
Matrix1D<double> &classesProbs, Matrix1D<double> &allCosts)
{
classesProbs=__priorProbsLog10;
for(int f=0; f<Nfeatures; f++)
{
const LeafNode &leaf_f=*(__leafs[f]);
double newFeatures_f=DIRECT_A1D_ELEM(newFeatures,f);
for (int k=0; k<K; k++)
{
double p = leaf_f.assignProbability(newFeatures_f, k);
if (fabs(p) < 1e-2)
VEC_ELEM(classesProbs,k) += -2*DIRECT_A1D_ELEM(__weights,f);
else
VEC_ELEM(classesProbs,k) += DIRECT_A1D_ELEM(__weights,f)*std::log10(p);
#ifdef DEBUG_FINE_CLASSIFICATION
if(debugging == true)
{
std::cout << "Feature " << f
<< " Probability for class " << k << " = "
<< classesProbs(k) << " increase= " << p
<< std::endl;
char c;
// COSS std::cin >> c;
// if (c=='q') debugging = false;
}
#endif
}
}
classesProbs-=classesProbs.computeMax();
// std::cout << "classesProbs " << classesProbs.transpose() << std::endl;
for (int k=0; k<K; k++)
VEC_ELEM(classesProbs,k)=pow(10.0,VEC_ELEM(classesProbs,k));
classesProbs*=1.0/classesProbs.sum();
// std::cout << "classesProbs norm " << classesProbs.transpose() << std::endl;
allCosts=__cost*classesProbs;
// std::cout << "allCosts " << allCosts.transpose() << std::endl;
int bestk=0;
cost=VEC_ELEM(allCosts,0)=std::log10(VEC_ELEM(allCosts,0));
for (int k=1; k<K; k++)
{
VEC_ELEM(allCosts,k)=std::log10(VEC_ELEM(allCosts,k));
if (VEC_ELEM(allCosts,k)<cost)
{
cost=VEC_ELEM(allCosts,k);
bestk=k;
}
}
#ifdef DEBUG_CLASSIFICATION
if(debugging == true)
{
for (int k=0; k<K; k++)
classesProbs(k)=log10(classesProbs(k));
std::cout << "Class probababilities=" << classesProbs.transpose()
<< "\n costs=" << allCosts.transpose()
<< " best class=" << bestk << " cost=" << cost << std::endl;
char c;
// COSS std::cin >> c;
// if (c=='q') debugging = false;
}
#endif
return bestk;
}
//#define DEBUG
double spatial_Bspline03_proj(
const Matrix1D<double> &r, const Matrix1D<double> &u)
{
// Avoids divisions by zero and allows orthogonal rays computation
static Matrix1D<double> ur(3);
if (XX(u) == 0) XX(ur) = XMIPP_EQUAL_ACCURACY;
else XX(ur) = XX(u);
if (YY(u) == 0) YY(ur) = XMIPP_EQUAL_ACCURACY;
else YY(ur) = YY(u);
if (ZZ(u) == 0) ZZ(ur) = XMIPP_EQUAL_ACCURACY;
else ZZ(ur) = ZZ(u);
// Some precalculated variables
double x_sign = SGN(XX(ur));
double y_sign = SGN(YY(ur));
double z_sign = SGN(ZZ(ur));
// Compute the minimum and maximum alpha for the ray
double alpha_xmin = (-2 - XX(r)) / XX(ur);
double alpha_xmax = (2 - XX(r)) / XX(ur);
double alpha_ymin = (-2 - YY(r)) / YY(ur);
double alpha_ymax = (2 - YY(r)) / YY(ur);
double alpha_zmin = (-2 - ZZ(r)) / ZZ(ur);
double alpha_zmax = (2 - ZZ(r)) / ZZ(ur);
double alpha_min = XMIPP_MAX(XMIPP_MIN(alpha_xmin, alpha_xmax),
XMIPP_MIN(alpha_ymin, alpha_ymax));
alpha_min = XMIPP_MAX(alpha_min, XMIPP_MIN(alpha_zmin, alpha_zmax));
double alpha_max = XMIPP_MIN(XMIPP_MAX(alpha_xmin, alpha_xmax),
XMIPP_MAX(alpha_ymin, alpha_ymax));
alpha_max = XMIPP_MIN(alpha_max, XMIPP_MAX(alpha_zmin, alpha_zmax));
if (alpha_max - alpha_min < XMIPP_EQUAL_ACCURACY) return 0.0;
#ifdef DEBUG
std::cout << "Pixel: " << r.transpose() << std::endl
<< "Dir: " << ur.transpose() << std::endl
<< "Alpha x:" << alpha_xmin << " " << alpha_xmax << std::endl
<< " " << (r + alpha_xmin*ur).transpose() << std::endl
<< " " << (r + alpha_xmax*ur).transpose() << std::endl
<< "Alpha y:" << alpha_ymin << " " << alpha_ymax << std::endl
<< " " << (r + alpha_ymin*ur).transpose() << std::endl
<< " " << (r + alpha_ymax*ur).transpose() << std::endl
<< "Alpha z:" << alpha_zmin << " " << alpha_zmax << std::endl
<< " " << (r + alpha_zmin*ur).transpose() << std::endl
<< " " << (r + alpha_zmax*ur).transpose() << std::endl
<< "alpha :" << alpha_min << " " << alpha_max << std::endl
<< std::endl;
#endif
// Compute the first point in the volume intersecting the ray
static Matrix1D<double> v(3);
V3_BY_CT(v, ur, alpha_min);
V3_PLUS_V3(v, r, v);
#ifdef DEBUG
std::cout << "First entry point: " << v.transpose() << std::endl;
std::cout << " Alpha_min: " << alpha_min << std::endl;
#endif
// Follow the ray
double alpha = alpha_min;
double ray_sum = 0;
do
{
double alpha_x = (XX(v) + x_sign - XX(r)) / XX(ur);
double alpha_y = (YY(v) + y_sign - YY(r)) / YY(ur);
double alpha_z = (ZZ(v) + z_sign - ZZ(r)) / ZZ(ur);
// Which dimension will ray move next step into?, it isn't neccesary to be only
// one.
double diffx = ABS(alpha - alpha_x);
double diffy = ABS(alpha - alpha_y);
double diffz = ABS(alpha - alpha_z);
double diff_alpha = XMIPP_MIN(XMIPP_MIN(diffx, diffy), diffz);
ray_sum += spatial_Bspline03_integral(r, ur, alpha, alpha + diff_alpha);
// Update alpha and the next entry point
if (ABS(diff_alpha - diffx) <= XMIPP_EQUAL_ACCURACY) alpha = alpha_x;
if (ABS(diff_alpha - diffy) <= XMIPP_EQUAL_ACCURACY) alpha = alpha_y;
if (ABS(diff_alpha - diffz) <= XMIPP_EQUAL_ACCURACY) alpha = alpha_z;
XX(v) += diff_alpha * XX(ur);
YY(v) += diff_alpha * YY(ur);
ZZ(v) += diff_alpha * ZZ(ur);
#ifdef DEBUG
std::cout << "Alpha x,y,z: " << alpha_x << " " << alpha_y
<< " " << alpha_z << " ---> " << alpha << std::endl;
std::cout << " Next entry point: " << v.transpose() << std::endl
<< " diff_alpha: " << diff_alpha << std::endl
<< " ray_sum: " << ray_sum << std::endl
<< " Alfa tot: " << alpha << "alpha_max: " << alpha_max <<
std::endl;
#endif
}
while ((alpha_max - alpha) > XMIPP_EQUAL_ACCURACY);
return ray_sum;
}
