int computeStackLevels_Box(MultiDimFloatTexture tex, ref MultiDimFloatTexture[] _lvls)
{
List <MultiDimFloatTexture> tmplvls = new List <MultiDimFloatTexture>();
// compute stack of averages on large texture
// . add unmodifed finest level
tmplvls.Clear();
tmplvls.Add(tex);
int l = 0;
MultiDimFloatTexture lvl = tex;
float [] lvlDat = lvl.getData();
int num = (int)(0.01 + BMathLib.log2((float)lvl.getWidth()));
do // TODO: speed this up - extremely unefficient !!! (not critical though)
{
stack_accessor_v2 access = new stack_accessor_v2(l); // l is destination level for children
// (children *are* at level l)
MultiDimFloatTexture stackl = new MultiDimFloatTexture(lvl.getWidth(), lvl.getHeight(), lvl.numComp());
List <float> avg = new List <float>();
for (int q = 0; q < lvl.numComp(); q++)
{
avg.Add(0);
}
for (int i = 0; i < stackl.getWidth(); i++)
{
for (int j = 0; j < stackl.getHeight(); j++)
{
for (int q = 0; q < avg.Count; q++)
{
avg[q] = 0;
}
for (int li = 0; li < 2; li++)
{
for (int lj = 0; lj < 2; lj++)
{
int ci = 0, cj = 0;
access.child_ij(i, j, li, lj, ref ci, ref cj);
//CLM large amount of modification here.. check back w/ origional if problems occur
if (ci < 0 || ci >= lvl.getWidth() ||
cj < 0 || cj >= lvl.getHeight())
{
continue;
}
int idx = lvl.getpixmodIndex(ci, cj);
for (int c = 0; c < stackl.numComp(); c++)
{
avg[c] += lvlDat[idx + c];
}
}
}
int opix = stackl.getpixIndex(i, j);
for (int c = 0; c < stackl.numComp(); c++)
{
stackl.getData()[opix + c] = avg[c] / 4.0f;
}
}
}
lvl = stackl;
tmplvls.Add(lvl);
l++;
} while ((1 << l) <= lvl.getWidth());
// clamp stack
int w = tex.getWidth() / 2;
int h = tex.getHeight() / 2;
_lvls = new MultiDimFloatTexture[m_iNbLevels];
l = 0;
int sz = w;
for (int i = 0; i < tmplvls.Count; i++)
{
MultiDimFloatTexture ktex = tmplvls[i];
MultiDimFloatTexture clamped = ktex.extract(w / 2, h / 2, w, h);
_lvls[i] = clamped;
l++;
sz >>= 1;
if (sz < 1)
{
break;
}
}
for (int i = 0; i < tmplvls.Count; i++)
{
tmplvls[i] = null;
}
tmplvls.Clear();
return((int)_lvls.Length);
}
void computeSynthNeighborhoods()
{
ScopeTimer tm = new ScopeTimer("[computeSynthNeighborhoods]");
m_SynthNeighborhoods = new NeighborhoodSynth[mNumLevels][];
// foreach level
for (int level = 0; level < mNumLevels; level++)
{
MultiDimFloatTexture recolored_level = null;
if (Globals.isDefined("4D"))
{
// . keep only 4 dimension from recolored exemplar
MultiDimFloatTexture level_4D = new MultiDimFloatTexture(mOwner.recoloredStack(level).width(), mOwner.recoloredStack(level).height(), mOwner.recoloredStack(level).numComp());
int w = level_4D.getWidth();
int h = level_4D.getHeight();
Globals.Assert(w == mOwner.stack(level).getWidth() && h == mOwner.stack(level).height());
Globals.Assert(level_4D.numComp() == Globals.NUM_RECOLORED_PCA_COMPONENTS);
for (int i = 0; i < w; i++)
{
for (int j = 0; j < h; j++)
{
// . copy first four channels
for (int c = 0; c < 4; c++)
{
level_4D.set(mOwner.recoloredStack(level).get(i, j, c), i, j, c);
}
// . zero out all channels above 4
for (int c = 4; c < level_4D.numComp(); c++)
{
level_4D.set(0, i, j, c);
}
}
}
recolored_level = level_4D;
}
else
{
// . keep all dimensions
recolored_level = mOwner.recoloredStack(level);
}
m_SynthNeighborhoods[level] = new NeighborhoodSynth[recolored_level.width() * recolored_level.height()];
stack_accessor_v2 access = new stack_accessor_v2(level);
for (int j = 0; j < recolored_level.height(); j++)
{
for (int i = 0; i < recolored_level.width(); i++)
{
int index = i + j * recolored_level.width();
m_SynthNeighborhoods[level][index] = new NeighborhoodSynth();
m_SynthNeighborhoods[level][index].construct(
recolored_level,
access,
(!mOwner.isToroidal()) && level < (mNumLevels - Globals.NUM_LEVELS_WITHOUT_BORDER),
//(!m_bToroidal) && l < FIRST_LEVEL_WITH_BORDER,
level, i, j);
}
}
}
tm.destroy();
tm = null;
}