void volume_file_info::calcMinMax(unsigned int var, unsigned int time) const
{
thread_info ti(BOOST_CURRENT_FUNCTION);
volume vol;
const uint64 maxdim = 128; //read in 128^3 chunks
for(unsigned int off_z = 0; off_z < ZDim(); off_z+=maxdim)
for(unsigned int off_y = 0; off_y < YDim(); off_y+=maxdim)
for(unsigned int off_x = 0; off_x < XDim(); off_x+=maxdim)
{
dimension read_dim(std::min(XDim()-off_x,maxdim),
std::min(YDim()-off_y,maxdim),
std::min(ZDim()-off_z,maxdim));
readVolumeFile(vol,filename(),var,time,
off_x,off_y,off_z,read_dim);
if(off_x==0 && off_y==0 && off_z==0)
{
_data._min[var][time] = vol.min();
_data._max[var][time] = vol.max();
}
else
{
if(_data._min[var][time] > vol.min())
_data._min[var][time] = vol.min();
if(_data._max[var][time] < vol.max())
_data._max[var][time] = vol.max();
}
}
_data._minIsSet[var][time] = true;
_data._maxIsSet[var][time] = true;
}
/*
* Invert the matrix if x = -1
* use gaussj
*/
FMatrix FMatrix::operator^( int x ) const
{
assert( x == -1 ); /* may want to extend to 2... in the future */
// check dimension
assert( XDim() == YDim() );
// convience variables
int n = XDim();
int size = n*n;
// make a copy of the matrix for nrc routine to work on
float *copy = new float[ size ];
memcpy( copy, elem, size*sizeof(float) );
float **a = convert_matrix( copy, 1, n, 1, n );
float **b = matrix( 1, n, 1, 1 );
b[1][1] = 1.0F;
for( int i = 2; i <= n; i++ )
b[i][1] = 0.0F;
gaussj( a, n, b, 1 );
FMatrix ret( n, n );
for( int iy = 0; iy < n; iy++ )
for( int ix = 0; ix < n; ix++ )
ret.Elem( iy, ix ) = copy[ iy*n + ix ];
delete [] copy;
free_matrix( b, 1, n, 1, 1 );
free_convert_matrix( a, 1, n, 1, n );
return( ret );
}
/*
* Increment
*/
FMatrix& FMatrix::operator+=( const FMatrix &M )
{
// check dimension
assert( XDim() == M.XDim() && YDim() == M.YDim() );
for( int iy = 0; iy < ydim; iy++ )
for( int ix = 0; ix < xdim; ix++ )
elem[ iy*xdim + ix ] += M.rElem( iy, ix );
return( *this );
}
/*
* Multiply the matrix
* nxm matrix multiply by mxr matrix gives nxr matrix
*/
FMatrix FMatrix::operator*( const FMatrix &M ) const
{
// check dimension
assert( XDim() == M.YDim() );
// assign convience variables
int n = YDim();
int m = XDim();
int r = M.XDim();
FMatrix ret( n, r );
ret = 0;
for( int in = 0; in < n; in++ )
for( int ir = 0; ir < r; ir++ )
for( int im = 0; im < m; im++ )
ret.Elem( in, ir ) += rElem( in, im ) * M.rElem( im, ir );
return( ret );
}
Voxels& Voxels::anisotropicDiffusion(unsigned int iterations)
{
CVC::ThreadInfo ti(BOOST_CURRENT_FUNCTION);
double cn, cs, ce, cw, cu, cd;
double delta_n, delta_s, delta_e, delta_w, delta_u, delta_d;
double K_para = 3;
double Lamda_para = 0.16f;
unsigned int m;
VolMagick::uint64 i,j,k, stepnum = 0;
Voxels tempt(*this);
if(_vosm) _vosm->start(this, VoxelOperationStatusMessenger::AnisotropicDiffusion, ZDim()*iterations);
uint64 numSteps = ZDim()*iterations;
for (m=0; m<iterations; m++)
{
for (k=0; k<ZDim(); k++)
{
for (j=0; j<YDim(); j++)
for (i=0; i<XDim(); i++)
{
if (j < YDim()-1)
delta_s = (*this)(i,j+1,k) - (*this)(i,j,k);
else
delta_s = 0.0;
if (j > 0)
delta_n = (*this)(i,j-1,k) - (*this)(i,j,k);
else
delta_n = 0.0;
if (i < XDim()-1)
delta_e = (*this)(i+1,j,k) - (*this)(i,j,k);
else
delta_e = 0.0;
if (i > 0)
delta_w = (*this)(i-1,j,k) - (*this)(i,j,k);
else
delta_w = 0.0;
if (k < ZDim()-1)
delta_u = (*this)(i,j,k+1) - (*this)(i,j,k);
else
delta_u = 0.0;
if (k > 0)
delta_d = (*this)(i,j,k-1) - (*this)(i,j,k);
else
delta_d = 0.0;
cn = 1.0f / (1.0f + ((delta_n * delta_n) / (K_para * K_para)));
cs = 1.0f / (1.0f + ((delta_s * delta_s) / (K_para * K_para)));
ce = 1.0f / (1.0f + ((delta_e * delta_e) / (K_para * K_para)));
cw = 1.0f / (1.0f + ((delta_w * delta_w) / (K_para * K_para)));
cu = 1.0f / (1.0f + ((delta_u * delta_u) / (K_para * K_para)));
cd = 1.0f / (1.0f + ((delta_d * delta_d) / (K_para * K_para)));
tempt(i,j,k,
(*this)(i,j,k) +
Lamda_para * (cn * delta_n + cs * delta_s + ce * delta_e +
cw * delta_w + cu * delta_u + cd * delta_d));
}
if(_vosm) _vosm->step(this, VoxelOperationStatusMessenger::AnisotropicDiffusion, stepnum);
cvcapp.threadProgress(float(stepnum)/float(numSteps));
stepnum++;
}
(*this) = tempt;
}
if(_vosm) _vosm->end(this, VoxelOperationStatusMessenger::AnisotropicDiffusion);
cvcapp.threadProgress(1.0f);
return *this;
}
