void main1_3(void *arg)
{
color Kd = color(diffuse(), diffuse(), diffuse());
normal Nf = faceforward(normalize(N()), I());
vector V = -normalize(I());
while (illuminance(P(), Nf, PI / 2.0f))
{
color C = 0.0f;
SAMPLE_LIGHT_2(color, C, 0.0f,
C += Cl() * (
color_() * Kd * (normalize(L()) % Nf)
+ cosinePower() * specularColor() * specularbrdf(normalize(L()), Nf, V, 0.1f/*roughness()*/)
)
);
Ci() += C;
}
if ( ! less_than( &transparency(), LIQ_SCALAR_ALMOST_ZERO ) )
{//transparent
Ci() = Ci() * ( 1.0f - transparency() ) + trace_transparent() * transparency();
}//else{ opacity }
setOutputForMaya();
}
/** After the running shader on the complete grid return the compute Ci
* \param x Integer Raster position.
* \param y Integer Raster position.
*/
CqColor CqImagersource::Color( TqFloat x, TqFloat y )
{
CqColor result = gColBlack;
TqInt index = static_cast<TqInt>( ( y - m_uYOrigin ) * ( m_uGridRes + 1 ) + x - m_uXOrigin );
if ( (TqInt)Ci() ->Size() >= index )
Ci() ->GetColor( result, index );
return result;
}
void main1(void *arg)
{
color Kd = color(diffuse(), diffuse(), diffuse());
normal Nf = faceforward(normalize(N()), I());
vector V = -normalize(I());
while (illuminance(P(), Nf, PI / 2.0f))
{
color C = 0.0f;
color last = 0.0f;
int num_samples = 0;
while (sample_light())
{
C += Cl() * (
color_() * Kd * (normalize(L()) % Nf)
+ cosinePower() * specularColor() * specularbrdf(normalize(L()), Nf, V, 0.1f/*roughness()*/)
);
++ num_samples;
if ((num_samples % 4) == 0)
{
color current = C * (1.0f / (scalar)num_samples);
if (converged(current, last)){
break;
}
last = current;
}
}
C *= (1.0f / (scalar)num_samples);
Ci() += C;
}
if ( ! less_than( &transparency(), LIQ_SCALAR_ALMOST_ZERO ) )
{//transparent
Ci() = Ci() * ( 1.0f - transparency() ) + trace_transparent() * transparency();
}//else{ opacity }
setOutputForMaya();
}
void SparseMatrixF :: ReadDiagonal(double *dv)
{
for ( unsigned long j = 0; j < neq; j++ ) {
for ( unsigned long ad = Adr(j); ad < Adr(j + 1); ad++ ) {
unsigned long i = Ci(ad);
if ( i == j ) {
dv [ j ] = a [ ad ];
}
}
}
}
void SparseMatrixF :: GetA12block(double *pA12, long c)
{
for ( unsigned long j = neq - c; j < neq; j++ ) {
for ( unsigned long ad = Adr(j); ad < Adr(j + 1); ad++ ) {
unsigned long i = Ci(ad);
if ( i < ( neq - c ) ) {
pA12 [ i * c + ( j - ( neq - c ) ) ] = a [ ad ];
}
}
}
}
void SparseMatrixF :: MulSymMatrixByVector(double *b, double *c)
{
for ( unsigned long j = 0; j < neq; j++ ) {
for ( unsigned long ad = Adr(j); ad < Adr(j + 1); ad++ ) {
double A = a [ ad ];
unsigned long i = Ci(ad);
c [ i ] += A * b [ j ];
if ( i != j ) {
c [ j ] += A * b [ i ];
}
}
}
}
bool Container::equalTree(Object const* o1, Object const * o2)
{
Q_ASSERT(o1 && o2);
if(o1==o2)
return true;
bool eq= o1->type()==o2->type();
switch(o2->type()) {
case Object::variable:
eq = eq && Ci(o2)==Ci(o1);
break;
case Object::value:
eq = eq && Cn(o2)==Cn(o1);
break;
case Object::container:
eq = eq && Container(o2)==Container(o1);
break;
case Object::oper:
eq = eq && Operator(o2)==Operator(o1);
break;
default:
break;
}
return eq;
}
bool Foam::functionObjects::writeCellCentres::write()
{
volVectorField C
(
IOobject
(
"C",
time_.timeName(),
mesh_,
IOobject::NO_READ,
IOobject::NO_WRITE,
false
),
mesh_.C(),
calculatedFvPatchScalarField::typeName
);
Log << " Writing cell-centre field " << C.name()
<< " to " << time_.timeName() << endl;
C.write();
for (direction i=0; i<vector::nComponents; i++)
{
volScalarField Ci
(
IOobject
(
mesh_.C().name() + vector::componentNames[i],
time_.timeName(),
mesh_,
IOobject::NO_READ,
IOobject::NO_WRITE,
false
),
mesh_.C().component(i)
);
Log << " Writing the "
<< vector::componentNames[i]
<< " component field of the cell-centres " << Ci.name()
<< " to " << time_.timeName() << endl;
Ci.write();
}
return true;
}
void SparseMatrixF :: mxv_scr(double *b, double *c)
{
unsigned long i, j, ii, lj, uj;
double s, d;
for ( i = 0; i < neq; i++ ) {
lj = Adr(i);
uj = Adr(i + 1);
s = 0.0;
d = b [ i ];
for ( j = lj; j < uj; j++ ) {
ii = Ci(j);
s += a [ j ] * b [ ii ];
c [ ii ] += a [ j ] * d;
}
c [ i ] = s;
}
}
RMMTree(stream_type & in, base_layer_type const & rB)
:
B(rB),
n(libmaus::util::NumberSerialisation::deserialiseNumber(in)),
numlevels(libmaus::util::NumberSerialisation::deserialiseNumber(in)),
I(libmaus::util::NumberSerialisation::deserialiseNumber(in)),
C(libmaus::util::NumberSerialisation::deserialiseNumber(in)),
S(in)
{
for ( uint64_t i = 0; i < I.size(); ++i )
{
libmaus::bitio::CompactArray::unique_ptr_type tIi(new libmaus::bitio::CompactArray(in));
I[i] = UNIQUE_PTR_MOVE(tIi);
}
for ( uint64_t i = 0; i < C.size(); ++i )
{
C_ptr_type Ci(C_type::load(in));
C[i] = UNIQUE_PTR_MOVE(Ci);
}
}
//---------------------------------------------------------------------
void CqImagersource::Initialise( const CqRegion& DRegion, IqChannelBuffer* buffer )
{
AQSIS_TIME_SCOPE(Imager_shading);
// We use one less than the bucket width and height here, since these
// resolutions really represent one less than the number of shaded points
// in each direction. (Usually they describe the number of micropolygons
// on a grid which is one less than the number of shaded vertices. This
// concept has no real analogue in context of an imager shader.)
TqInt uGridRes = DRegion.width()-1;
TqInt vGridRes = DRegion.height()-1;
TqInt x = DRegion.xMin();
TqInt y = DRegion.yMin();
m_uYOrigin = static_cast<TqInt>( y );
m_uXOrigin = static_cast<TqInt>( x );
m_uGridRes = uGridRes;
m_vGridRes = vGridRes;
TqInt mode = QGetRenderContext() ->poptCurrent()->GetIntegerOption( "System", "DisplayMode" ) [ 0 ];
TqFloat components;
TqInt j, i;
TqFloat shuttertime = QGetRenderContext() ->poptCurrent()->GetFloatOption( "System", "Shutter" ) [ 0 ];
components = mode & DMode_RGB ? 3 : 0;
components += mode & DMode_A ? 1 : 0;
components = mode & DMode_Z ? 1 : components;
TqInt Uses = ( 1 << EnvVars_P ) | ( 1 << EnvVars_Ci ) | ( 1 << EnvVars_Oi | ( 1 << EnvVars_ncomps ) | ( 1 << EnvVars_time ) | ( 1 << EnvVars_alpha ) | ( 1 << EnvVars_s ) | ( 1 << EnvVars_t ) );
m_pShaderExecEnv->Initialise( uGridRes, vGridRes, uGridRes * vGridRes, (uGridRes+1)*(vGridRes+1), true, IqAttributesPtr(), IqTransformPtr(), m_pShader.get(), Uses );
// Initialise the geometric parameters in the shader exec env.
TqInt numShadingPoints = (uGridRes+1) * (vGridRes+1);
P() ->Initialise( numShadingPoints );
Ci() ->Initialise( numShadingPoints );
Oi() ->Initialise( numShadingPoints );
alpha() ->Initialise( numShadingPoints );
s() ->Initialise( numShadingPoints );
t() ->Initialise( numShadingPoints );
//TODO dtime is not initialised yet
//dtime().Initialise(uGridRes, vGridRes, i);
ncomps() ->SetFloat( components );
time() ->SetFloat( shuttertime );
m_pShader->Initialise( uGridRes, vGridRes, (uGridRes+1)*(vGridRes+1), m_pShaderExecEnv.get() );
TqUint CiIndex = buffer->getChannelIndex("Ci");
TqUint OiIndex = buffer->getChannelIndex("Oi");
TqUint coverageIndex = buffer->getChannelIndex("coverage");
for ( j = 0; j < vGridRes+1; j++ )
{
for ( i = 0; i < uGridRes+1; i++ )
{
TqInt off = j * ( uGridRes + 1 ) + i;
P() ->SetPoint( CqVector3D( x + i, y + j, 0.0 ), off );
Ci() ->SetColor( CqColor((*buffer)(i, j, CiIndex)[0], (*buffer)(i, j, CiIndex)[1], (*buffer)(i, j, CiIndex)[2]), off );
CqColor opa((*buffer)(i, j, OiIndex)[0], (*buffer)(i, j, OiIndex)[1], (*buffer)(i, j, OiIndex)[2]);
Oi() ->SetColor( opa, off );
TqFloat avopa = ( opa.r() + opa.g() + opa.b() ) /3.0f;
alpha() ->SetFloat( (*buffer)(i, j, coverageIndex)[0] * avopa, off );
s() ->SetFloat( x + i + 0.5, off );
t() ->SetFloat( y + j + 0.5, off );
}
}
// Execute the Shader VM
if ( m_pShader )
{
m_pShader->Evaluate( m_pShaderExecEnv.get() );
alpha() ->SetFloat( 1.0f ); /* by default 3delight/bmrt set it to 1.0 */
}
}
static
bool smoother_conjugate_gradient(
double i_tvis,
const PlaneData &i_rhs,
PlaneData &io_x,
double *i_domain_size,
double i_error_threshold = 0.000001,
int i_max_iters = 999999999,
double i_omega = 0.1, //not needed in CG
int i_verbosity = 0
)
{
const PlaneData &b = i_rhs;
PlaneData &x = io_x;
double inv_helm_h[2];
inv_helm_h[0] = (double)i_rhs.planeDataConfig->physical_data_size[0]/(double)i_domain_size[0];
inv_helm_h[1] = (double)i_rhs.planeDataConfig->physical_data_size[1]/(double)i_domain_size[1];
double scalar_Dx = 1.0*(inv_helm_h[0]*inv_helm_h[0]);
double scalar_Dy = 1.0*(inv_helm_h[1]*inv_helm_h[1]);
double scalar_C = -(2.0*(inv_helm_h[0]*inv_helm_h[0]) + 2.0*(inv_helm_h[1]*inv_helm_h[1]));
const double res_kernel[9] = {
0, scalar_Dy, 0,
scalar_Dx, scalar_C, scalar_Dx,
0, scalar_Dy, 0
};
#define A(x) (x - i_tvis*x.op_stencil_Re_3x3(res_kernel))
#if 0
double foo = 1.0/std::sqrt(i_kappa.real() - i_gh0*scalar_C);
double c_re = foo;
double c_im = foo;
c_re = 1;
c_im = 1;
# define Ci(x) (x.multiply_real_imag(c_re, c_im))
#else
# define Ci(x) (x)
#endif
PlaneData r = b - A(x);
PlaneData w = Ci(r);
PlaneData v = Ci(w);
// TODO: should we maybe use the conjugate dot product?
double alpha = (w*w).reduce_sum();
if (i_verbosity > 3)
std::cout << "RESIDUAL: " << r.reduce_rms() << std::endl;
int i = 0;
for (i = 0; i < i_max_iters; i++)
{
// if (v.reduce_rms() < i_error_threshold)
// return true;
PlaneData u = A(v);
double t = alpha / (v*u).reduce_sum();
x = x + t*v;
r = r - t*u;
w = Ci(r);
double beta = (w*w).reduce_sum();
if (std::abs(beta) < i_error_threshold)
{
if (r.reduce_rms() < i_error_threshold)
{
if (i_verbosity > 0)
std::cout << "FIN RESIDUAL: " << (b-A(x)).reduce_rms() << " after " << i << " iterations" << std::endl;
return true;
}
}
//if (i_verbosity > 3)
x.print_physicalArrayData();
r.print_physicalArrayData();
std::cout << "RESIDUAL: " << r.reduce_rms() << std::endl;
double s = beta / alpha;
v = Ci(w) + v*s;
alpha = beta;
}
#undef A
#undef Ci
return false;
}
/**
* The optimal community structure is a subdivision of the network into
* nonoverlapping groups of nodes in a way that maximizes the number of
* within-group edges, and minimizes the number of between-group edges.
* The modularity is a statistic that quantifies the degree to which the
* network may be subdivided into such clearly delineated groups.
*
* The Louvain algorithm is a fast and accurate community detection
* algorithm (as of writing). The algorithm may also be used to detect
* hierarchical community structure.
*
* Input: W undirected (weighted or binary) connection matrix.
* gamma, modularity resolution parameter (optional)
* gamma>1 detects smaller modules
* 0<=gamma<1 detects larger modules
* gamma=1 (default) classic modularity
*
* Outputs: Ci, community structure
* Q, modularity
* Note: Ci and Q may vary from run to run, due to heuristics in the
* algorithm. Consequently, it may be worth to compare multiple runs.
*
* Reference: Blondel et al. (2008) J. Stat. Mech. P10008.
* Reichardt and Bornholdt (2006) Phys Rev E 74:016110.
*/
urowvec Connectome::modularity_louvain(mat W, double *Qopt, double gamma)
{
uint N = W.n_rows, h = 1, n = N, u =0, ma =0, mb =0;
double s = accu(W), wm = 0, max_dQ = -1;
uvec M, t;
rowvec dQ;
field<urowvec> Ci(20);
Ci(0) = urowvec(); Ci(1) = linspace<urowvec>(0,n-1,n);
rowvec Q = "-1,0";
while (Q(h)-Q(h-1) > 1e-10) {
rowvec K = sum(W,0), Km = K;
mat Knm = W;
M = linspace<uvec>(0,n-1,n);
bool flag = true;
while (flag) {
flag = false;
arma_rng::set_seed_random();
t = shuffle(linspace<uvec>(0,n-1,n));
for (uint i =0;i<n;++i) {
u = t(i);
ma = M(u);
dQ = Knm.row(u) - Knm(u,ma)+W(u,u)-
gamma*K(u)*(Km-Km(ma)+K(u))/s;
dQ(ma) = 0;
max_dQ = dQ.max();
mb = as_scalar(find(dQ == max_dQ,1));
if (max_dQ > 1e-10) {
flag = true;
M(u) = mb;
Knm.col(mb) += W.col(u);
Knm.col(ma) -= W.col(u);
Km(mb) += K(u);
Km(ma) -= K(u);
}
}
}
Ci(++h) = zeros<urowvec>(1,N);
M = matlabUnique(M);
for (uint u=0;u<n;++u) {
Ci(h)(find(Ci(h-1) == u)).fill(M(u));
}
n = M.max()+1;
mat w = zeros(n,n);
for (uint u =0;u<n;++u)
for (uint v=u;v<n;++v) {
wm = accu(W(find(M==u),find(M==v)));
w(u,v) = wm;
w(v,u) = wm;
}
W = w;
Q.resize(h+1);
Q(h) = trace(W)/s - gamma*accu((W*W)/(s*s));
}
*Qopt = Q(h);
return Ci(h);
}
void SparseMatrixF :: MulNonsymMatrixByVector(double *b, double *c)
{
switch ( m_eSparseOrientation ) {
case eCompressedColumns:
{
for ( unsigned long j = 0; j < neq; j++ ) {
for ( unsigned long ad = Adr(j); ad < Adr(j + 1); ad++ ) {
double A = a [ ad ];
unsigned long i = Ci(ad);
c [ i ] += A * b [ j ];
}
}
}
break;
case eCompressedRows:
{
for ( unsigned long j = 0; j < neq; j++ ) {
for ( unsigned long ad = Adr(j); ad < Adr(j + 1); ad++ ) {
double A = a [ ad ];
unsigned long i = Ci(ad);
c [ j ] += A * b [ i ];
}
}
}
break;
default:
fprintf(stderr, "SparseMatrixF::MulNonsymMatrixByVector: unsupported m_eSparseOrientation value\n");
abort();
}
}
