void AddUniformCentroid(Destin *d, uint l)
{
uint i, j, ni, nb, np, ns, idx;
Node * n = GetNodeFromDestin(d, l, 0, 0);
nb = n->nb;
ni = n->ni;
np = n->np;
ns = n->ns;
idx = ni + nb;
// Layer l
float * newMu, * newSigma, * newAvgDelta, * newAvgSquaredDelta;
MALLOCV(newMu, float, (ns+1));
MALLOCV(newSigma, float, (ns+1));
MALLOCV(newAvgDelta, float, (ns+1));
MALLOCV(newAvgSquaredDelta, float, (ns+1));
_generateNewUniformCentroidMu(d, l, VICINITY_OF_ADDED_CENTROID, newMu);
for (j=0; j < ns+1; j++)
{
newSigma[j] = INIT_SIGMA;
newAvgDelta[j] = 0;
newAvgSquaredDelta[j] = 0;
}
for (i = 0; i < nb; i++)
{
ArrayInsertFloat(&d->uf_mu[l][i], ns, idx, 0);
_normalizeMu(d->uf_mu[l][i], ni, nb+1, np);
ArrayInsertFloat(&d->uf_sigma[l][i], ns, idx, INIT_SIGMA);
ArrayInsertFloat(&d->uf_avgDelta[l][i], ns, idx, 0);
ArrayInsertFloat(&d->uf_avgSquaredDelta[l][i], ns, idx, 0);
}
ArrayInsertFloat(&d->uf_absvar[l], ns, idx, 0);
ArrayInsertFloat(&d->uf_avgAbsDelta[l], ns, idx, 0);
ArrayAppendPtr((void *)&d->uf_mu[l], nb, newMu);
ArrayAppendPtr((void *)&d->uf_sigma[l], nb, newSigma);
ArrayAppendUInt(&d->uf_winCounts[l], nb, 0);
ArrayAppendLong(&d->uf_persistWinCounts[l], nb, 0);
ArrayAppendLong(&d->uf_persistWinCounts_detailed[l], nb, 0);
ArrayAppendPtr((void *)&d->uf_avgDelta[l], nb, newAvgDelta);
ArrayAppendPtr((void *)&d->uf_avgSquaredDelta[l], nb, newAvgSquaredDelta);
ArrayAppendFloat(&d->uf_starv[l], nb, 1);
ArrayAppendFloat(&d->uf_winFreqs[l], nb, 1/(float) nb);
_normalizeFloatArray(d->uf_winFreqs[l], nb+1);
d->nb[l]++; // increase global number of centroids for layer l
for (j = 0; j < d->layerSize[l]; j++)
{
n =& d->nodes[d->layerNodeOffsets[l] + j];
ArrayAppendFloat(&n->belief, nb, 0);
ArrayAppendFloat(&n->beliefEuc, nb, 0);
ArrayAppendFloat(&n->beliefMal, nb, 0);
ArrayAppendFloat(&n->outputBelief, nb, 0);
ArrayInsertFloat(&n->delta, ns, idx, 0);
ArrayInsertFloat(&n->observation, ns, idx, 0);
// increase centroid dimensionality for each node from layer l
UpdateNodeSizes(n, n->ni, nb+1, n->np, n->nc);
// pointers may change due to reallocation
n->mu = d->uf_mu[l];
n->starv = d->uf_starv[l];
}
// Layer l+1
if (l+1 < d->nLayers)
{
n = GetNodeFromDestin(d, l+1, 0, 0);
ns = n->ns;
uint childIndexes[n->nChildren]; // indexes of added centroids for all childs
float childValues[n->nChildren]; // initial values for all childs
float childSigmas[n->nChildren];
for (i = 0; i < n->nChildren; i++)
{
childIndexes[i] = (i+1)*nb;
childValues[i] = 0;
childSigmas[i] = INIT_SIGMA;
}
for (i = 0; i < n->nb; i++)
{
ArrayInsertFloats(&d->uf_mu[l+1][i], ns, childIndexes, childValues, n->nChildren);
ArrayInsertFloats(&d->uf_sigma[l+1][i], ns, childIndexes, childSigmas, n->nChildren);
ArrayInsertFloats(&d->uf_avgDelta[l+1][i], ns, childIndexes, childValues, n->nChildren);
ArrayInsertFloats(&d->uf_avgSquaredDelta[l+1][i], ns, childIndexes, childValues, n->nChildren);
}
ArrayInsertFloats(&d->uf_absvar[l+1], ns, childIndexes, childValues, n->nChildren);
ArrayInsertFloats(&d->uf_avgAbsDelta[l+1], ns, childIndexes, childValues, n->nChildren);
for (j = 0; j < d->layerSize[l+1]; j++)
{
n =& d->nodes[d->layerNodeOffsets[l+1] + j];
ArrayInsertFloats(&n->delta, ns, childIndexes, childValues, n->nChildren);
ArrayInsertFloats(&n->observation, ns, childIndexes, childValues, n->nChildren);
// increase centroid dimensionality for each node from layer l+1
UpdateNodeSizes(n, n->ni + n->nChildren, n->nb, n->np, n->nc);
// pointers may change due to reallocation
n->mu = d->uf_mu[l+1];
n->starv = d->uf_starv[l+1];
}
}
// Layer l-1
if (l > 0)
{
n = GetNodeFromDestin(d, l-1, 0, 0);
ns = n->ns;
uint pIdx = n->ni + n->nb + n->np; // index of added parent centroid
for (i = 0; i < n->nb; i++)
{
ArrayInsertFloat(&d->uf_mu[l-1][i], ns, pIdx, 0);
_normalizeMu(d->uf_mu[l-1][i], n->ni, n->nb, n->np+1);
ArrayInsertFloat(&d->uf_sigma[l-1][i], ns, pIdx, INIT_SIGMA);
ArrayInsertFloat(&d->uf_avgDelta[l-1][i], ns, pIdx, 0);
ArrayInsertFloat(&d->uf_avgSquaredDelta[l-1][i], ns, pIdx, 0);
}
ArrayInsertFloat(&d->uf_absvar[l-1], ns, pIdx, 0);
ArrayInsertFloat(&d->uf_avgAbsDelta[l-1], ns, pIdx, 0);
for (j = 0; j < d->layerSize[l-1]; j++)
{
n =& d->nodes[d->layerNodeOffsets[l-1] + j];
ArrayInsertFloat(&n->delta, ns, pIdx, 0);
ArrayInsertFloat(&n->observation, ns, pIdx, 0);
// increase centroid dimensionality for each node from layer l-1
UpdateNodeSizes(n, n->ni, n->nb, n->np+1, n->nc);
// pointers may change due to reallocation
n->mu = d->uf_mu[l-1];
n->starv = d->uf_starv[l-1];
}
}
}
PetscErrorCode FiberFieldInitLocalFiber( FiberField fibers, int numVerticies, PetscReal l0,
FiberTypeID vertexType, FiberTypeID edgeType, FiberTypeID bendingEdgeType )
{
int i;
int flen = numVerticies;
Array fiber = fibers->fiber;
Vertex v0;
Vertex v1;
Vertex v2;
PetscRandom rnd = fibers->rnd;
PetscBool hitBoundary;
Coor rndSphere;
Coor n;
Coor r;
Coor s;
Coor d;
Coor lmin = fibers->localBounds.min;
Coor lmax = fibers->localBounds.max;
PetscReal NORTH_HEMISPHERE = 0.65;
const PetscReal WHOLE_SPHERE = 0.0;
const PetscReal DELTA = PETSC_SMALL;
PetscErrorCode ierr;
PetscFunctionBegin;
ierr = ArraySetSize(fiber, 0); CHKERRQ(ierr);
ierr = ArraySetMaxSize( fibers->verts, flen + ArrayLength(fibers->verts) ); CHKERRQ(ierr);
// add small delta
lmin.x += DELTA;
lmin.y += DELTA;
lmin.z += DELTA;
lmax.x -= DELTA;
lmax.y -= DELTA;
lmax.z -= DELTA;
ierr = PetscOptionsGetReal(0,"-fiber_bend",&NORTH_HEMISPHERE,0); CHKERRQ(ierr);
// Initialize v0 anywhere in the local bbox
ierr = FiberFieldAddVertex( fibers, vertexType, &v0); CHKERRQ(ierr);
ierr = ArrayAppendPtr( fiber, v0); CHKERRQ(ierr);
PetscRandomGetValue(rnd,&v0->X.x); // [0,1]
PetscRandomGetValue(rnd,&v0->X.y); // [0,1]
PetscRandomGetValue(rnd,&v0->X.z); // [0,1]
// map [0, 1] to local bbox [lmin, lmax]
v0->X.x = (1-v0->X.x) * lmin.x + v0->X.x * lmax.x;
v0->X.y = (1-v0->X.y) * lmin.y + v0->X.y * lmax.y;
v0->X.z = (1-v0->X.z) * lmin.z + v0->X.z * lmax.z;
// Initialize v1 anywhere spherically from v0
ierr = FiberFieldAddVertex( fibers, vertexType, &v1); CHKERRQ(ierr);
ierr = ArrayAppendPtr( fiber, v1); CHKERRQ(ierr);
SphericalDistribution(rnd, WHOLE_SPHERE, &d);
v1->X.x = v0->X.x + l0*d.x;
v1->X.y = v0->X.y + l0*d.y;
v1->X.z = v0->X.z + l0*d.z;
BoundaryCheck( lmin, lmax, &v1->X, &hitBoundary );
if (hitBoundary) {
ierr = FiberFieldAddEdge( fibers, v0, v1, edgeType, l0 ); CHKERRQ(ierr);
PetscFunctionReturn(0);
}
for (i = 1; i < flen-1; i++ ) {
ierr = FiberFieldAddVertex( fibers, vertexType, &v2); CHKERRQ(ierr);
ierr = ArrayAppendPtr( fiber, v2); CHKERRQ(ierr);
SphericalDistribution(rnd, NORTH_HEMISPHERE, &rndSphere);
Rotation(v0->X,v1->X,&n,&r,&s);
MatVec(&n,&r,&s,&rndSphere, &d);
v2->X.x = v1->X.x + l0*d.x;
v2->X.y = v1->X.y + l0*d.y;
v2->X.z = v1->X.z + l0*d.z;
BoundaryCheck( lmin, lmax, &v2->X, &hitBoundary );
if (hitBoundary) {
break;
}
v0 = v1;
v1 = v2;
}
flen = ArrayLength( fiber );
Vertex *v = ArrayGetData( fiber );
// Link fiber edges: v_i -- v_i+1
for (i = 0; i < flen-1; i++) {
ierr = FiberFieldAddEdge( fibers, v[i], v[i+1], edgeType, l0 ); CHKERRQ(ierr);
}
// Link bending edges: v_i-1 -- v_i+1
for (i = 1; i < flen-1; i++) {
ierr = FiberFieldAddEdge( fibers, v[i-1], v[i+1], bendingEdgeType, 2*l0 ); CHKERRQ(ierr);
}
PetscFunctionReturn(0);
}
//function for adding rescaled centroids to the existing system.
//Here each node has an extra belief dimensionality(an extra centroid)
void AddRescaledCentroids(Destin *destin,uint l,float * rcentroid,uint centid)
{
uint i,j,ns,nb,np,idx,ni;
Node * n = GetNodeFromDestin(destin, l, 0, 0);
nb = n->nb;ni = n->ni;np = n->np;ns = n->ns;
idx = ni + nb;
float * rMu, * rSigma, * rAvgDelta, * rAvgSquaredDelta;
//if rescaled function was already called before we delete duplicate centroids
if(destin->rescale==1)
{
for(i=rindex;i<destin->nb[l];i++)
{
DeleteUniformCentroid(destin,l,i);
}
}
//allocate space for uniform centroid location
destin->rindex=ni+nb;
MALLOCV(rMu, float, (ns+1));
MALLOCV(rSigma, float, (ns+1));
MALLOCV(rAvgDelta, float, (ns+1));
MALLOCV(rAvgSquaredDelta, float, (ns+1));
//initializing rMu with rescaled centroid size
for(i=0;i<ns;i++)
{
rMu[i]=rcentroid[i];
}
//initializing rsigma,rAvgDelta and rAvgSquaredDelta
for (j=0; j < ns+1; j++)
{
rSigma[j] = INIT_SIGMA;
rAvgDelta[j] = 0;
rAvgSquaredDelta[j] = 0;
}
//similiar to add uniform centroids in centroid.c
for (i = 0; i < nb; i++)
{
ArrayInsertFloat(&destin->uf_mu[l][i], ns, idx, 0);
_normalizeMu(destin->uf_mu[l][i], ni, nb+1, np);
ArrayInsertFloat(&destin->uf_sigma[l][i], ns, idx, INIT_SIGMA);
ArrayInsertFloat(&destin->uf_avgDelta[l][i], ns, idx, 0);
ArrayInsertFloat(&destin->uf_avgSquaredDelta[l][i], ns, idx, 0);
}
ArrayInsertFloat(&destin->uf_absvar[l], ns, idx, 0);
ArrayInsertFloat(&destin->uf_avgAbsDelta[l], ns, idx, 0);
ArrayAppendPtr((void *)&destin->uf_mu[l], nb, rMu);
ArrayAppendPtr((void *)&destin->uf_sigma[l], nb, rSigma);
ArrayAppendUInt(&destin->uf_winCounts[l], nb, 0);
ArrayAppendLong(&destin->uf_persistWinCounts[l], nb, 0);
ArrayAppendLong(&destin->uf_persistWinCounts_detailed[l], nb, 0);
ArrayAppendPtr((void *)&destin->uf_avgDelta[l], nb, rAvgDelta);
ArrayAppendPtr((void *)&destin->uf_avgSquaredDelta[l], nb, rAvgSquaredDelta);
ArrayAppendFloat(&destin->uf_starv[l], nb, 1);
ArrayAppendFloat(&destin->uf_winFreqs[l], nb, 1/(float) nb);
_normalizeFloatArray(destin->uf_winFreqs[l], nb+1);
destin->nb[l]++; // increase global number of centroids for layer l
for (j = 0; j < destin->layerSize[l]; j++)
{
n =& destin->nodes[destin->layerNodeOffsets[l] + j];
ArrayAppendFloat(&n->belief, nb, 0);
ArrayAppendFloat(&n->beliefEuc, nb, 0);
ArrayAppendFloat(&n->beliefMal, nb, 0);
ArrayAppendFloat(&n->outputBelief, nb, 0);
ArrayInsertFloat(&n->delta, ns, idx, 0);
ArrayInsertFloat(&n->observation, ns, idx, 0);
// increase centroid dimensionality for each node from layer l
UpdateNodeSizes(n, n->ni, nb+1, n->np, n->nc);
// pointers may change due to reallocation
n->mu = destin->uf_mu[l];
n->starv = destin->uf_starv[l];
}
if (l+1 < destin->nLayers)
{
n = GetNodeFromDestin(destin, l+1, 0, 0);
ns = n->ns;
uint childIndexes[n->nChildren]; // indexes of added centroids for all childs
float childValues[n->nChildren]; // initial values for all childs
float childSigmas[n->nChildren];
for (i = 0; i < n->nChildren; i++)
{
childIndexes[i] = (i+1)*nb;
childValues[i] = 0;
childSigmas[i] = INIT_SIGMA;
}
for (i = 0; i < n->nb; i++)
{
ArrayInsertFloats(&destin->uf_mu[l+1][i], ns, childIndexes, childValues, n->nChildren);
ArrayInsertFloats(&destin->uf_sigma[l+1][i], ns, childIndexes, childSigmas, n->nChildren);
ArrayInsertFloats(&destin->uf_avgDelta[l+1][i], ns, childIndexes, childValues, n->nChildren);
ArrayInsertFloats(&destin->uf_avgSquaredDelta[l+1][i], ns, childIndexes, childValues, n->nChildren);
}
ArrayInsertFloats(&destin->uf_absvar[l+1], ns, childIndexes, childValues, n->nChildren);
ArrayInsertFloats(&destin->uf_avgAbsDelta[l+1], ns, childIndexes, childValues, n->nChildren);
for (j = 0; j < destin->layerSize[l+1]; j++)
{
n =& destin->nodes[destin->layerNodeOffsets[l+1] + j];
ArrayInsertFloats(&n->delta, ns, childIndexes, childValues, n->nChildren);
ArrayInsertFloats(&n->observation, ns, childIndexes, childValues, n->nChildren);
// increase centroid dimensionality for each node from layer l+1
UpdateNodeSizes(n, n->ni + n->nChildren, n->nb, n->np, n->nc);
// pointers may change due to reallocation
n->mu = destin->uf_mu[l+1];
n->starv = destin->uf_starv[l+1];
}
}
// Layer l-1
if (l > 0)
{
n = GetNodeFromDestin(destin, l-1, 0, 0);
ns = n->ns;
uint pIdx = n->ni + n->nb + n->np; // index of added parent centroid
for (i = 0; i < n->nb; i++)
{
ArrayInsertFloat(&destin->uf_mu[l-1][i], ns, pIdx, 0);
_normalizeMu(destin->uf_mu[l-1][i], n->ni, n->nb, n->np+1);
ArrayInsertFloat(&destin->uf_sigma[l-1][i], ns, pIdx, INIT_SIGMA);
ArrayInsertFloat(&destin->uf_avgDelta[l-1][i], ns, pIdx, 0);
ArrayInsertFloat(&destin->uf_avgSquaredDelta[l-1][i], ns, pIdx, 0);
}
ArrayInsertFloat(&destin->uf_absvar[l-1], ns, pIdx, 0);
ArrayInsertFloat(&destin->uf_avgAbsDelta[l-1], ns, pIdx, 0);
for (j = 0; j < destin->layerSize[l-1]; j++)
{
n =& destin->nodes[destin->layerNodeOffsets[l-1] + j];
ArrayInsertFloat(&n->delta, ns, pIdx, 0);
ArrayInsertFloat(&n->observation, ns, pIdx, 0);
// increase centroid dimensionality for each node from layer l-1
UpdateNodeSizes(n, n->ni, n->nb, n->np+1, n->nc);
// pointers may change due to reallocation
n->mu = destin->uf_mu[l-1];
n->starv = destin->uf_starv[l-1];
}
}
return;
}
