CSplittingCondition *CKDTreeMedianSplittingFactory::createSplittingCondition(DataSubset *dataSubset)
{
DataSubset::iterator it = dataSubset->begin();
ColumnVector minVector(inputData->getNumDimensions());
ColumnVector maxVector(inputData->getNumDimensions());
ColumnVector *vector = (*inputData)[*it];
minVector = *vector;
maxVector = *vector;
it ++;
for (; it != dataSubset->end(); it ++)
{
ColumnVector *vector = (*inputData)[*it];
for (int i = 0; i < inputData->getNumDimensions(); i ++)
{
if (vector->element(i) < minVector.element(i))
{
minVector.element(i) = vector->element(i);
}
if (vector->element(i) > maxVector.element(i))
{
maxVector.element(i) = vector->element(i);
}
}
}
maxVector = maxVector - minVector;
//cout << "Dimension Width: " << maxVector.t();
int index = 0;
maxVector.maximum1(index);
index --;
std::vector<double> median;
it = dataSubset->begin();
//printf("Values : ");
double mean = 0.0;
for (; it != dataSubset->end(); it ++)
{
ColumnVector *vector = (*inputData)[*it];
// median.push_back(vector->element(index));
// printf("%f ", vector->element(index));
mean += vector->element(index);
}
mean /= dataSubset->size();
//std::sort(median.begin(), median.end());
double treshold = mean; //median[median.size() / 2];
// cout << "Dimension " << index << " Median " << treshold << endl;
return new C1DSplittingCondition(index, treshold);
}
CvPoint3D32f Model::getRealCoordinatesFromVoxelMap(int u, int v, int w) {
//Matrix worldMat(4, 1);
//worldMat = 0;
float modelContents[] = { u, v, w, 1 };
ColumnVector modelMat(4);
modelMat << modelContents;
// [x,y,z,1] ?
// [x,y,z,1] = convMat^{-1} * [u,v,w,1]
//cvSolve(&A, &b, &x); // solve (Ax=b) for x
// cvSolve(convMat, &modelMat, &worldMat);
ColumnVector worldMat = convMat.i() * modelMat;
//printCvMat(&worldMat);
float x = worldMat.element(0);
float y = worldMat.element(1);
float z = worldMat.element(2);
//LOG4CPLUS_DEBUG(myLogger, "(u,v,w)=("<< u <<","<<v<<","<<w<<") -> (x,y,z)=(" << x <<","<<y<<","<<z<<")");
CvPoint3D32f p = cvPoint3D32f(x, y, z);
return p;
}
void SpinAdapted::xsolve_AxeqB(const Matrix& a, const ColumnVector& b, ColumnVector& x)
{
FORTINT ar = a.Nrows();
int bc = 1;
int info=0;
FORTINT* ipiv = new FORTINT[ar];
double* bwork = new double[ar];
for(int i = 0;i<ar;++i)
bwork[i] = b.element(i);
double* workmat = new double[ar*ar];
for(int i = 0;i<ar;++i)
for(int j = 0;j<ar;++j)
workmat[i*ar+j] = a.element(j,i);
GESV(ar, bc, workmat, ar, ipiv, bwork, ar, info);
delete[] ipiv;
delete[] workmat;
for(int i = 0;i<ar;++i)
x.element(i) = bwork[i];
delete[] bwork;
if(info != 0)
{
pout << "Xsolve failed with info error " << info << endl;
abort();
}
}
/** Utility printing function. */
void printColumnVector(ColumnVector &v, std::ostream *out, const std::string& delim) {
int nRow = v.Nrows();
int i = 0;
if(out == NULL)
out = &cout;
for(i = 0; i < nRow - 1; i++)
(*out) << v.element(i) << delim;
(*out) << v.element(i);
}
void CActorFromContinuousActionGradientPolicy::receiveError(double critic, CStateCollection *oldState, CAction *Action, CActionData *data)
{
gradientETraces->updateETraces(Action->getDuration());
CContinuousActionData *contData = NULL;
if (data)
{
contData = dynamic_cast<CContinuousActionData *>(data);
}
else
{
contData = dynamic_cast<CContinuousActionData *>(Action->getActionData());
}
assert(gradientPolicy->getRandomController());
ColumnVector *noise = gradientPolicy->getRandomController()->getLastNoise();
if (DebugIsEnabled('a'))
{
DebugPrint('a', "ActorCritic Noise: ");
policyDifference->saveASCII(DebugGetFileHandle('a'));
}
for (int i = 0; i < gradientPolicy->getNumOutputs(); i ++)
{
gradientFeatureList->clear();
gradientPolicy->getGradient(oldState, i, gradientFeatureList);
gradientETraces->addGradientETrace(gradientFeatureList, noise->element(i));
}
gradientPolicy->updateGradient(gradientETraces->getGradientETraces(), critic * getParameter("ActorLearningRate"));
}
double CLocalRBFRegression::doRegression(ColumnVector *vector, DataSubset *subset)
{
// cout << "NNs for Input " << vector->t() << endl;
DataSubset::iterator it = subset->begin();
/* for (int i = 0; it != subset->end(); it ++, i++)
{
ColumnVector dist(*vector);
dist = dist - *(*input)[*it];
printf("(%d %f) ", *it, dist.norm_Frobenius());
}
printf("\n"); */
ColumnVector *rbfFactors = getRBFFactors(vector, subset);
it = subset->begin();
double value = 0;
for (int i = 0; it != subset->end(); it ++, i++)
{
value += rbfFactors->element(i) * (*output)[*it];
}
double sum = rbfFactors->sum();
if (sum > 0)
{
value = value / sum;
}
//printf("Value: %f %f ", value ,sum);
//cout << rbfFactors->t();
return value;
}
bool SpectClust::MaxEigen(const Matrix &M, double &maxValue, ColumnVector &MaxVec, int maxIterations) {
double maxDelta = 1e-6;
bool converged = false;
int i = 0;
int nRows = M.Ncols();
if(M.Ncols() != M.Nrows())
Err::errAbort("MaxEigen() - Can't get eigen values of non square matrices.");
if(M.Ncols() <= 0)
Err::errAbort("MaxEigen() - Must have positive number of rows and columns.");
ColumnVector V(M.Ncols());
V = 1.0 / M.Nrows(); // any vector really...
V = V / Norm1(V);
MaxVec.ReSize(M.Ncols());
for(i = 0; i < maxIterations; ++i) {
// MaxVec = M * V;
multByMatrix(MaxVec, V, M);
double delta = 0;
double norm = sqrt(SumSquare(MaxVec));
for(int vIx = 0; vIx < nRows; vIx++) {
MaxVec.element(vIx) = MaxVec.element(vIx) / norm; // scale so we don't get too big.
}
for(int rowIx = 0; rowIx < nRows; rowIx++) {
delta += fabs((double)MaxVec.element(rowIx) - V.element(rowIx));
}
if(delta < maxDelta)
break; // we've already converged to eigen vector.
V = MaxVec;
}
if(i < maxIterations) {
converged = true;
}
// calculate approximate max eigen value using Rayleigh quotient (x'*M*x/x'*x).
Matrix num = (MaxVec.t() * M * MaxVec);
Matrix denom = (MaxVec.t() * MaxVec);
maxValue = num.element(0,0) / denom.element(0,0);
return converged;
}
void FnirtFileWriter::common_coef_construction(const string& fname,
const basisfield& fieldx,
const basisfield& fieldy,
const basisfield& fieldz,
const Matrix& aff)
{
volume4D<float> coefs(fieldx.CoefSz_x(),fieldx.CoefSz_y(),fieldx.CoefSz_z(),3);
vector<float> ksp(3,1.0);
try {
const splinefield& f = dynamic_cast<const splinefield& >(fieldx);
ksp[0] = float(f.Ksp_x()); ksp[1] = float(f.Ksp_y()); ksp[2] = float(f.Ksp_z());
if (f.Order() == 2) coefs.set_intent(FSL_QUADRATIC_SPLINE_COEFFICIENTS,f.Vxs_x(),f.Vxs_y(),f.Vxs_z());
else if (f.Order() == 3) coefs.set_intent(FSL_CUBIC_SPLINE_COEFFICIENTS,f.Vxs_x(),f.Vxs_y(),f.Vxs_z());
}
catch (...) {
try {
const dctfield& f = dynamic_cast<const dctfield& >(fieldx);
coefs.set_intent(FSL_DCT_COEFFICIENTS,f.Vxs_x(),f.Vxs_y(),f.Vxs_z());
throw FnirtFileWriterException("common_coef_construction: Saving of DCT coefficients not yet implemented");
}
catch (...) {
throw FnirtFileWriterException("common_coef_construction: Unknown field type");
}
}
coefs.setxdim(ksp[0]); coefs.setydim(ksp[1]); coefs.setzdim(ksp[2]);
Matrix qform(4,4);
qform = IdentityMatrix(4);
qform(1,4) = fieldx.FieldSz_x();
qform(2,4) = fieldx.FieldSz_y();
qform(3,4) = fieldx.FieldSz_z();
coefs.set_qform(NIFTI_XFORM_SCANNER_ANAT,qform);
coefs.set_sform(NIFTI_XFORM_SCANNER_ANAT,aff);
vector<shared_ptr<ColumnVector> > coefp(3);
coefp[0]=fieldx.GetCoef(); coefp[1]=fieldy.GetCoef(); coefp[2]=fieldz.GetCoef();
for (unsigned int v=0; v<3; v++) {
ColumnVector c = *(coefp[v]);
for (unsigned int k=0, vindx=0; k<fieldx.CoefSz_z(); k++) {
for (unsigned int j=0; j<fieldx.CoefSz_y(); j++) {
for (unsigned int i=0; i<fieldx.CoefSz_x(); i++) {
coefs(i,j,k,v) = c.element(vindx++);
}
}
}
}
save_orig_volume4D(coefs,fname);
}
ColumnVector *CLocalRBFRegression::getRBFFactors(ColumnVector *vector, DataSubset *subset)
{
DataSubset::iterator it = subset->begin();
for (int i = 0; it != subset->end(); it ++, i ++)
{
double malDist = 0;
for (int j = 0; j < vector->nrows(); j ++)
{
ColumnVector *data = (*input)[*it];
malDist += pow((vector->element(j) - data->element(j)) / sigma->element(j), 2.0);
}
rbfFactors->element(i) = exp(- malDist / 2.0);
}
// cout << "RBFFactors: " << rbfFactors->t() << endl;
return rbfFactors;
}
bool AMC::LeastSquares::doLeastSquares(Matrix& A, double* dataCube, int width, int height, int nBands, int nEndmembers, double* abundanceFractions, int& currentX, int& currentY)
{
Logger::stringLine("doLeastSquares ...");
currentX = 0;
currentY = 0;
int row, col;
int nrows = height, ncols = width;
int band;
int i, j, k, iterations;
Matrix* A_tilde;
int index = -1;
double max1, max2, max_total = 0.0;
double change, mu, deviation;
double anglefield[255*255];
bool bError=false;
// here we go...
// ATTENTION: Internally we work here with col-oriented matrixfile,
// but the user has to enter the spectra row-wise for his/her's
// convenience... That means: Don't mix row- and col-orientation
// in source code and modules messages output!
//
//Spectral Matrix is stored in A now (diagonally flipped to input
// file) Generally: n: cols .... for matrix A
// m: rows
// |
// |
//
// 1. Check matrix orthogonality:
// Ref: Youngsinn Sohn, Roger M. McCoy 1997: Mapping desert shrub
// rangeland using spectral unmixing and modeling spectral
// mixtrues with TM data. Photogrammetric Engineering &
// Remote Sensing, Vol.63, No6.
//
//
// 2. Beside checking matrix orthogonality we find out the maximum
// entry of the matrix for configuring stepsize mu later.
double curr_angle = 0.0;
for (i = 0; i < A.Ncols(); i++) // go columnwise through matrix
{
MatrixCol Avector1(&A,LoadOnEntry,i);
max1 = Avector1.Maximum1(INT_MIN, index); // get the max. element of this vector
for (j = 0; j < A.Ncols(); j++)
{
if (j != i)
{
MatrixCol Avector2(&A,LoadOnEntry,j); // get next col in A
max2 = Avector2.Maximum1(INT_MIN, index); // get the max. element of this vector
max_total = find_max(max1, max2); // find max of matrix A
curr_angle = Utilities::getSpectralAngle(Avector1, Avector2); // check vector angle
anglefield[i+ j*255] = ((float)curr_angle / PI) * 180; // save angle in degree
}
}
}
Logger::stringLine(" -Checking linear dependencies (orthogonality check) of Matrix A");
// print out the result
for (i = 0; i < A.Ncols(); i++)
{
for (j = 0; j < A.Ncols(); j++)
{
if (j != i)
{
char buff[500];
// internally this is col and not row certainly
sprintf(buff, " -Angle between row %d and row %d: %f degree",(i + 1), (j + 1), anglefield[i+ j*255]);
Logger::stringLine(buff);
}
}
}
// check it
//Logger::stringLine("Checking Orthogonality");
//bError = false;
//
//for (i = 0; i < A.Ncols(); i++)
//{
// for (j = 0; j < A.Ncols(); j++)
// {
// if (j != i)
// {
// if (anglefield[i+ j*255] < 8.0) //was 8.0 in the original algorithm of GRASS
// {
// char buff[500];
// // internally this is col and not row certainly
// sprintf(buff, " -ERROR: Spectral entries row %d: and row %d: in your matrix are linear dependent!",(i+1), (j+1));
// Logger::stringLine(buff);
// Logger::stringLine(" -You have to revise your reference spectra");
// bError = true;
// }
// }
// }
//}
//
if (!bError)
{
Logger::stringLine("Spectral matrix is o.k. Proceeding...");
}
else
{
Logger::stringLine("doLeastSquares FAILED !");
return false;
}
//if (!flag.quiet->answer)
//Console.WriteLine("Spectra matrix is o.k. Proceeding...\n\n");
/// Begin calculations //////////////////////////////////////////////////////////////////////////
// 1. Constraint SUM xi = 1
// add last row "1" elements to Matrix A, store in A_tilde
// A_tilde is one row-dimension more than A
A_tilde = new Matrix(A.Nrows() + 1, A.Ncols()); // memory allocation
for (i = 0; i < A.Nrows(); i++) // copy row wise
for (j = 0; j < A.Ncols(); j++) // copy col wise
A_tilde->element(i, j) = A.element(i, j);
// fill last row with 1 elements
for (j = 0; j < A.Ncols(); j++)
(*A_tilde).element(A.Nrows(), j) = (double)(GAMMA);
/// ---- now we have an overdetermined (non-square) system
// We have a least square problem here: error minimization
// T -1 T
// unknown fraction = [A_tilde * A_tilde] * A_tilde * b
//
// A_tilde is the non-square matrix with first constraint in last row.
// b is pixel vector from satellite image
//
// Solve this by deriving above equation and searching the
// minimum of this error function in an iterative loop within
// both constraints.
// calculate the transpose of A_tilde
Matrix A_tilde_trans = A_tilde->t();
// initialize some values
// step size must be small enough for convergence of iteration:
// mu=0.000001; step size for spectra in range of W/m^2/um
// mu=0.000000001; step size for spectra in range of mW/m^2/um
// mu=0.000001; step size for spectra in range of reflectance
////
// check max_total for number of digits to configure mu size
ColumnVector* fraction = NULL;
//mu = 0.000001 * pow(10, -1 * ceil(log10f((float)max_total)));
mu = 0.000000001;
ColumnVector startvector (A.Ncols()); // length: no. of spectra
ColumnVector A_times_startvector (A_tilde->Nrows()); // length: no. of bands
//MultipliedMatrix* A_times_startvector ; // length: no. of bands
ColumnVector errorvector (A_tilde->Nrows()); // length: no. of bands
//SubtractedMatrix* errorvector ;
ColumnVector temp (A_tilde->Ncols()); // length: no. of spectra
//MultipliedMatrix* temp;
Matrix A_tilde_trans_mu(A_tilde->Ncols(), A_tilde->Nrows());
//ScaledMatrix* A_tilde_trans_mu;
// Now we can calculate the fractions pixelwise
//nrows // get geographical region
//ncols
Logger::sstring("mu = ");Logger::decimal(mu);Logger::endl();
for (row = 0; row < nrows; row++) // rows loop in images
{
//if (!flag2.veryquiet->answer)
//G_percent(row, nrows, 1);
//
//for (band = 0; band < nBands; band++) //get one row for all bands
//{
//if (G_get_map_row (cellfd[band], cell[band], row) < 0)
//Application.Exit();
//}
for (col = 0; col < ncols; col++) // cols loop, work pixelwise for all bands
{
currentX = col;
currentY = row;
// get pixel values of each band and store in b vector:
ColumnVector b_gamma(A_tilde->Nrows()); // length: no. of bands + 1 (GAMMA)
for (band = 0; band < nBands; band++)
b_gamma.element(band) = (double)(dataCube[col+ row*width+band*height*width]);
// add GAMMA for 1. constraint as last element
b_gamma.element(nBands) = (double)(GAMMA);
{
//
Logger::endl();
Logger::sstring(" row, col\n");
Logger::sstring("( ");Logger::decimal(row+1);Logger::sstring(", ");Logger::decimal(col+1);Logger::sstring(") , pixelVector = ");//Logger::openStream() << b_gamma;Logger::closeStream();
Logger::endl();
Logger::stringLine("-----------------------------------------");
}
// calculate fraction vector for current pixel
// Result is stored in fractions vector
// with second constraint: Sum x_i = 1
change = 1000; // initialize
deviation = 1000;
iterations = 0;
for (k = 0; k < (A_tilde->Ncols()); k++) // no. of spectra times
startvector.element(k) = (double)((1.0 / A_tilde->Ncols()));
// get start vector and initialize it with equal fractions:
// using the neighbor pixelvector as startvector
// solve with iterative solution:
while (fabs(change) > LEAST_SQUARES_TOLERANCE) //0.0001
{
// go a small step into direction of negative gradient
A_times_startvector = ((*A_tilde) * startvector);
errorvector = *(A_times_startvector.Evaluate()) - b_gamma;
A_tilde_trans_mu = mu * *(A_tilde_trans.Evaluate());
temp = *(A_tilde_trans_mu.Evaluate()) * *(errorvector.Evaluate());
{
LOG_DISABLE
//Logger::getSingletonLoggerStream().width(5);
//Logger::getSingletonLoggerStream()<<iterations<<": startV = "<<startvector<<endl;
//Logger::getSingletonLoggerStream()<<" : A*stv = "<<A_times_startvector<<endl;
//Logger::getSingletonLoggerStream()<<" : errorV = "<<errorvector<<endl;
//Logger::getSingletonLoggerStream()<<" : temp = "<<temp<<endl;
LOG_END
}
startvector = startvector - *(temp.Evaluate()); /// update startvector
//if one element gets negative, set it to zero
for (k = 0; k < (A_tilde->Ncols()); k++) // no. of spectra times
{
if (startvector.element(k) < 0.0)
startvector.element(k) = 0.0;
}
// Check the deviation
MatrixCol errorCol(errorvector.Evaluate(),LoadOnEntry, 0);
double errorVectorNorm = errorCol.Norm2();
change = deviation - errorVectorNorm;
deviation = errorVectorNorm;
//LOG_START
//Logger::getSingletonLoggerStream()<<" : change = "<<change<<endl;
//Logger::getSingletonLoggerStream()<<" : deviation = "<<deviation<<endl;
//Logger::LogStringLine("-----------------------------------------");
//LOG_END
iterations++;
} // while
// length: no. of spectra
double error = deviation / MatrixCol(&b_gamma,LoadOnEntry).Norm2();
fraction = &startvector;
{
Logger::decimal(iterations,5);Logger::sstring(":");
Logger::sstring(" : fraction = ");//Logger::openStream() << *fraction;Logger::closeStream();
Logger::endl();
Logger::stringLine("=====================================================");
}
/// end of second constraint
// store fractions in resulting rows of resulting files
// (number of bands = vector dimension)
/// write result percent
for (i = 0; i < A.Ncols(); i++) // no. of spectra
abundanceFractions[i + col*nEndmembers+row*width*nEndmembers] = fraction->element(i);
// save error and iterations
//error_cell[col] = (CELL) (100 * error);
//iter_cell[col] = iterations;
} // columns loop
/// write the resulting rows into output files:
//for (i = 0; i < A.ncols; i++) // no. of spectra
// G_put_map_row(resultfd[i], result_cell[i]);
//if (error_fd > 0)
// G_put_map_row(error_fd, error_cell);
//if (iter_fd > 0)
// G_put_map_row(iter_fd, iter_cell);
} // rows loop
Logger::stringLine("doLeastSquares finished successfully !");
currentX = 0;
currentY = 0;
//delete A_tilde_trans_mu;
delete A_tilde;
return true;
}
CSplittingCondition *CExtraTreesSplittingConditionFactory::createSplittingCondition(DataSubset *dataSubset)
{
ColumnVector minVector(inputData->getNumDimensions());
ColumnVector maxVector(inputData->getNumDimensions());
DataSubset::iterator it = dataSubset->begin();
ColumnVector *vector = (*inputData)[*it];
minVector = *vector;
maxVector = *vector;
for (; it != dataSubset->end(); it ++)
{
ColumnVector *vector = (*inputData)[*it];
for (int i = 0; i < inputData->getNumDimensions(); i ++)
{
if (vector->element(i) < minVector.element(i))
{
minVector.element(i) = vector->element(i);
}
if (vector->element(i) > maxVector.element(i))
{
maxVector.element(i) = vector->element(i);
}
}
}
double bestScore = 0.0;
CSplittingCondition *bestSplit = NULL;
unsigned int i = 0;
int numValid = 0;
while (i < K || numValid == 0)
{
int dim = rand() % inputData->getNumDimensions();
double treshold = (((double) rand()) / RAND_MAX) * (maxVector.element(dim) - minVector.element(dim)) + minVector.element(dim);
CSplittingCondition *newSplit = new C1DSplittingCondition(dim, treshold);
double score = getScore( newSplit, dataSubset);
if ((score > bestScore || numValid == 0) && score <= 0.5)
{
bestScore = score;
if (bestSplit != NULL)
{
delete bestSplit;
}
bestSplit = newSplit;
}
else
{
delete newSplit;
}
if (score <= 0.5)
{
numValid ++;
}
i ++;
if (i > 100)
{
//printf("%d: %d %f\n", i, dataSubset->size(), score);
}
if (i > 200)
{
it = dataSubset->begin();
printf("Could not find a split for : \n");
for (; it != dataSubset->end(); it++)
{
cout << (*inputData)[*it]->t();
}
exit(0);
}
}
return bestSplit;
}