void FullBFMatrix::VertConcatBelowMe(const NEWMAT::Matrix& B)
{
if (!B.Ncols()) return;
if (int(Ncols()) != B.Ncols()) {throw BFMatrixException("FullBFMatrix::VertConcatBelowMe: Matrices must have same # of columns");}
*mp &= B;
}
void FullBFMatrix::VertConcat(const NEWMAT::Matrix& B, BFMatrix& AB) const
{
if (B.Ncols() && int(Ncols()) != B.Ncols()) {throw BFMatrixException("FullBFMatrix::VertConcat: Matrices must have same # of columns");}
FullBFMatrix *pAB = dynamic_cast<FullBFMatrix *>(&AB);
if (pAB) { // This means output is a full matrix
*pAB = *this;
pAB->VertConcatBelowMe(B);
}
else {
SparseBFMatrix<double> *psdAB = dynamic_cast<SparseBFMatrix<double> *>(&AB);
if (psdAB) {
*psdAB = SparseBFMatrix<double>(this->AsMatrix());
psdAB->VertConcatBelowMe(B);
}
else {
SparseBFMatrix<float> *psfAB = dynamic_cast<SparseBFMatrix<float> *>(&AB);
if (psfAB) {
*psfAB = SparseBFMatrix<float>(this->AsMatrix());
psfAB->VertConcatBelowMe(B);
}
else throw BFMatrixException("FullBFMatrix::VertConcat: dynamic cast error");
}
}
}
NEWMAT::Matrix rspfMatrix3x3::create(const NEWMAT::Matrix& rhs)
{
NEWMAT::Matrix m(3, 3);
if (rhs.Ncols() != 3 || rhs.Nrows() != 3)
{
rspfNotify(rspfNotifyLevel_FATAL) << "rspfMatrix3x3::create(const NEWMAT::Matrix& rhs) ERROR:"
<< "\nMatrix passed to function not a 3x3!"
<< "\nnumber of columns: " << rhs.Ncols()
<< "\nnumber of rows: " << rhs.Nrows()
<< "\nReturn blank 3x3 matrix...\n";
return m;
}
m[0][0] = rhs[0][0];
m[0][1] = rhs[0][1];
m[0][2] = rhs[0][2];
m[0][3] = rhs[0][3];
m[1][0] = rhs[1][0];
m[1][1] = rhs[1][1];
m[1][2] = rhs[1][2];
m[1][3] = rhs[1][3];
m[2][0] = rhs[2][0];
m[2][1] = rhs[2][1];
m[2][2] = rhs[2][2];
m[2][3] = rhs[2][3];
return m;
}
ossimMatrix4x4::ossimMatrix4x4(const NEWMAT::Matrix& m)
:theData(4,4)
{
if((m.Nrows() == 4) &&
(m.Ncols() == 4))
{
theData = m;
}
else if((m.Nrows()==3)&&
(m.Ncols()==3))
{
theData[0][0] = m[0][0];
theData[0][1] = m[0][1];
theData[0][2] = m[0][2];
theData[0][3] = 0.0;
theData[1][0] = m[1][0];
theData[1][1] = m[1][1];
theData[1][2] = m[1][2];
theData[1][3] = 0.0;
theData[2][0] = m[2][0];
theData[2][1] = m[2][1];
theData[2][2] = m[2][2];
theData[2][3] = 0.0;
theData[3][0] = 0.0;
theData[3][1] = 0.0;
theData[3][2] = 0.0;
theData[3][3] = 1.0;
}
else
{
theData[0][0] = 1.0;
theData[0][1] = 0.0;
theData[0][2] = 0.0;
theData[0][3] = 0.0;
theData[1][0] = 0.0;
theData[1][1] = 1.0;
theData[1][2] = 0.0;
theData[1][3] = 0.0;
theData[2][0] = 0.0;
theData[2][1] = 0.0;
theData[2][2] = 1.0;
theData[2][3] = 0.0;
theData[3][0] = 0.0;
theData[3][1] = 0.0;
theData[3][2] = 0.0;
theData[3][3] = 1.0;
}
}
void ossimFftFilter::fillMatrixForward(T *realPart,
T nullPix,
NEWMAT::Matrix& real,
NEWMAT::Matrix& img)const
{
ossim_uint32 w = real.Ncols();
ossim_uint32 h = real.Nrows();
ossim_uint32 yIdx = 0;
ossim_uint32 xIdx = 0;
for(yIdx = 0; yIdx < h; ++yIdx)
{
for(xIdx = 0; xIdx < w; ++xIdx)
{
if((double)(*realPart) != nullPix)
{
real[yIdx][xIdx] = (double)(*realPart);
}
else
{
real[yIdx][xIdx] = 0.0;
}
img[yIdx][xIdx] = 0.0;
++realPart;
}
}
}
rspfColumnVector3d rspfMatrix3x3::getEigenValues(const NEWMAT::Matrix& matrix)
{
if (matrix.Ncols() != 3 || matrix.Nrows() != 3)
{
rspfNotify(rspfNotifyLevel_FATAL) << "FATAL: rspfColumnVector3d operator*(const NEWMAT::Matrix& lhs,"
<< "\nconst rspfColumnVector3d& rhs), "
<< "\nMatrix passed to function not a 3x3!"
<< "\nnumber of columns: " << matrix.Ncols()
<< "\nnumber of rows: " << matrix.Nrows()
<< "\nReturn blank rspfColumnVector3d...\n";
return rspfColumnVector3d();
}
NEWMAT::DiagonalMatrix d;
NEWMAT::SymmetricMatrix s;
s << matrix;
NEWMAT::EigenValues(s, d);
return rspfColumnVector3d(d[0], d[1], d[2]);
}
void CUniversalKriging::Init_a(const CGridPoint& pt, CGridPointVector& va, NEWMAT::Matrix &a)const
{
ASSERT(a.Ncols() == a.Nrows());
size_t neq = va.size() + GetMDT();
// Initialize the main kriging matrix:
a.ReSize(int(neq), int(neq));
a = 0;
// Fill in the kriging matrix:
for (int i = 0; i < (int)va.size(); i++)
{
for (int j = i; j<(int)va.size(); j++)
{
double cov = m_pVariogram->cova3(va[i], va[j]);
a[i][j] = cov;
a[j][i] = cov;
}
}
// Fill in the OK unbiasedness portion of the matrix (if not doing SK):
if (!m_p.m_bSK)
{
double unbias = m_pVariogram->GetUnbias();
ASSERT(neq > va.size());
for (int i = 0; i < (int)va.size(); ++i)
{
a[(int)va.size()][i] = unbias;
a[i][(int)va.size()] = unbias;
}
}
// Add the additional Unbiasedness constraints:
int im = int(va.size()) + 1;
//const CDetrending& detrending = m_pVariogram->GetDetrending();
for (int i = 0; i < (int)m_externalDrift.size(); i++)
{
double resce = m_pVariogram->GetMaxCov() / max(LIMIT, m_externalDrift[i].GetE(pt));
//compute
for (int j = 0; j < (int)va.size(); j++)
{
a[im][j] = m_externalDrift[i].GetE(va[j])*resce;
a[j][im] = a[im][j];
}
im++;
}
}
void ossimFftFilter::fillMatrixInverse(T *realPart,
T *imgPart,
NEWMAT::Matrix& real,
NEWMAT::Matrix& img)const
{
ossim_uint32 w = real.Ncols();
ossim_uint32 h = real.Nrows();
ossim_uint32 yIdx = 0;
ossim_uint32 xIdx = 0;
for(yIdx = 0; yIdx < h; ++yIdx)
{
for(xIdx = 0; xIdx < w; ++xIdx)
{
real[yIdx][xIdx] = (double)(*realPart);
img[yIdx][xIdx] = (double)(*imgPart);
++realPart;
++imgPart;
}
}
}
double CUniversalKriging::Evaluate(const CGridPoint& pt, int iXval)const
{
//if variogram is not initialised correckly, we retuern no data;
if (!m_pVariogram->IsInit())
return m_param.m_noData;
// Find the nearest samples:
CGridPointVector va;
Init_va(pt, iXval, va);
int mdt = GetMDT();
// Test number of samples found:
// Test if there are enough samples to estimate all drift terms:
if ((int)va.size() < m_p.m_nbPoint || (int)va.size() <= mdt)
return m_param.m_noData;
if ( /*iXval<0 &&*/ va[0].GetDistance(pt) > m_param.m_maxDistance)
return m_param.m_noData;
// There are enough samples - proceed with estimation.
// Go ahead and set up the OK portion of the kriging matrix:
NEWMAT::ColumnVector r;
NEWMAT::Matrix a;
Init_a(pt, va, a);
Init_r(pt, va, r);
// If estimating the trend then reset all the right hand side terms=0.0:
if (m_p.m_bTrend)
r = 0;
//copy r to compute variance
NEWMAT::ColumnVector rr(r);
// Solve the kriging system:
int neq = mdt + int(va.size());
//reduce the matrix until the 2/3 of the number of neightbor
bool bOK = false;
while (!bOK && neq >= mdt + m_p.m_nbPoint * 2 / 3)//by RSA 25/10/2010
{
Try
{
a = a.i();
bOK = true;
}
Catch(NEWMAT::Exception)
{
OutputDebugStringW(L"a=a.i() failled; Reduce number of point");
Init_a(pt, va, a);
Init_r(pt, va, r);
neq--;
int firstRow = 1 + mdt + int(va.size()) - neq;
a = a.SubMatrix(firstRow, a.Nrows(), firstRow, a.Ncols());
r = r.SubMatrix(firstRow, r.Nrows(), 1, 1);
}
if (m_pAgent && m_pAgent->TestConnection(m_hxGridSessionID) == S_FALSE)
throw(CHxGridException());
}
//if we don't solve system, return missing
if (!bOK)
return m_param.m_noData;
NEWMAT::ColumnVector s = a*r;
CDiscretisation m_discr;
m_discr.Initialization(pt, *m_pVariogram, m_p, m_param.m_bFillNugget);
// Compute the solution:
double uuk = 0.0;
double ukv = m_discr.cbb;
for (int j = 0; j < neq; j++)
{
ukv -= s[j] * rr[j];
if (j < (int)va.size())
uuk += s[j] * (m_prePostTransfo.Transform(va[j].m_event) - m_p.m_SKmean);
}
uuk += m_p.m_SKmean;
uuk = m_prePostTransfo.InvertTransform(uuk, m_param.m_noData);
//
if ( /*iXval<0 &&*/ m_param.m_bRegionalLimit && uuk > m_param.m_noData)
{
CStatistic stat;
for (size_t i = 0; i < va.size(); i++)
stat += va[i].m_event;
bool bOutside = uuk<stat[LOWEST] - m_param.m_regionalLimitSD*stat[STD_DEV] || uuk>stat[HIGHEST] + m_param.m_regionalLimitSD*stat[STD_DEV];
if (bOutside)
{
if (m_param.m_bRegionalLimitToBound)
uuk = min(stat[HIGHEST] + m_param.m_regionalLimitSD*stat[STD_DEV], max(stat[LOWEST] - m_param.m_regionalLimitSD*stat[STD_DEV], uuk));
else
uuk = m_param.m_noData;
}
}
if ( /*iXval<0 &&*/ m_param.m_bGlobalLimit && uuk > m_param.m_noData)
{
bool bOutside = uuk<m_stat[LOWEST] - m_param.m_globalLimitSD*m_stat[STD_DEV] || uuk>m_stat[HIGHEST] + m_param.m_globalLimitSD*m_stat[STD_DEV];
if (bOutside)
{
if (m_param.m_bGlobalLimitToBound)
uuk = min(m_stat[HIGHEST] + m_param.m_globalLimitSD*m_stat[STD_DEV], max(m_stat[LOWEST] - m_param.m_globalLimitSD*m_stat[STD_DEV], uuk));
else
uuk = m_param.m_noData;
}
}
if ( /*iXval<0 &&*/ m_param.m_bGlobalMinMaxLimit && uuk > m_param.m_noData)
{
bool bOutside = uuk<m_param.m_globalMinLimit || uuk>m_param.m_globalMaxLimit;
if (bOutside)
{
if (m_param.m_bGlobalMinMaxLimitToBound)
uuk = min(m_param.m_globalMaxLimit, max(m_param.m_globalMinLimit, uuk));
else
uuk = m_param.m_noData;
}
}
return uuk;
}