public List <int> update(List <Window> requested, int lastsynthesizedlevel)
{
SynthWindows synthwins = new SynthWindows(requested, m_iBorderL, m_iBorderR, m_iBorderT, m_iBorderB, m_iPrefetchBorder);
if (synthwins.m_iNbLevels != m_iNbLevels)
{
throw new Exception("SynthWindows::update - can only update if the number of requested levels is the same !");
}
return(update(synthwins, lastsynthesizedlevel));
}
void computeNewRegions(int l, SynthWindows synthwins)
{
// compute update regions
// -> common synthesized part, express in new window coords, to be copied
Window absSynthCached = bufferrgn(l);
Window absSynthNew = synthwins.bufferrgn(l);
Window absOverlap = absSynthCached.overlap(absSynthNew);
Window absValidCached = valid(l).absoluteFrom(bufferrgn(l));
Window absValidNew = synthwins.valid(l).absoluteFrom(synthwins.bufferrgn(l));
Window absValidOverlap = absValidCached.overlap(absValidNew);
Pair <Window, Window> rgn = computeUpdateRegions(absValidNew, absValidOverlap);
m_UpdVert[l] = rgn.first.relativeTo(synthwins.bufferrgn(l));
m_UpdHorz[l] = rgn.second.relativeTo(synthwins.bufferrgn(l));
m_UpdCopySrc[l] = absValidOverlap.relativeTo(bufferrgn(l));
m_UpdCopyDst[l] = absValidOverlap.relativeTo(synthwins.bufferrgn(l));
m_BufferRgn[l] = synthwins.bufferrgn(l);
m_Valid[l] = synthwins.valid(l);
m_Requested[l] = synthwins.requested(l);
m_Cached[l] = synthwins.m_Cached[l];
}
public void updateSynthWindow()
{
m_Windows = new SynthWindows(Window.LTWH((int)mWindowMinX, (int)mWindowMinY, mWindowWidth, mWindowHeight), Globals.cNumLevels,
Globals.SYNTH_SUB1234_BORDER_L, Globals.SYNTH_SUB1234_BORDER_R, Globals.SYNTH_SUB1234_BORDER_T, Globals.SYNTH_SUB1234_BORDER_B, Globals.SYNTH_PREFETCH_BORDER);
}
public List <int> update(Window target)
{
SynthWindows synthwins = new SynthWindows(target, m_iNbLevels, m_iBorderL, m_iBorderR, m_iBorderT, m_iBorderB, m_iPrefetchBorder);
return(update(synthwins, 0));
}
// TODO : get rid of 'contains' => O(n) !!!!
List <int> update(SynthWindows synthwins, int lastsynthesizedlevel)
{
List <int> tobeupdated = new List <int>();
int nbearly = 0;
// STEP 1
// reuse some coarse levels ?
for (int l = m_iNbLevels - 1; l >= lastsynthesizedlevel; l--)
{
// is new requested window included in current valid window ?
// -> request window in absolute coords.
Window absreq = synthwins.absRequested(l);
// -> current valid in absolute coord.
Window absval = absValid(l);
// -> if current valid area does not include requested area, level cannot be reused
if (!absval.includes(absreq))
{
tobeupdated.Insert(0, l);
}
}
// STEP 2
// -> Early Update: if finest level request is closest than half prefetch, regen !
if (tobeupdated.Count < 1)
{
for (int l = m_iNbLevels - 1; l >= lastsynthesizedlevel; l--)
{
if (!contains(ref tobeupdated, l))
{
if (nbearly < 1)
{
Window absreq = synthwins.absRequested(l);
int dist = absreq.nestedBorderDistance(m_Cached[l]);
int thres = m_iPrefetchBorder / 2;
// cerr << l << " - thres " << thres << " - dist " << dist << endl;
if (dist < thres)
{
nbearly++;
tobeupdated.Insert(0, l);
}
}
}
}
}
// STEP 3
// -> from finest to coarsest
// update regions and check parents hold enough data
// skip finest
for (int l = lastsynthesizedlevel; l < m_iNbLevels; l++)
{
bool lpresent = contains(ref tobeupdated, l);
bool ladded = false;
if (l > 0 && !lpresent)
{
if (contains(ref tobeupdated, l - 1))
{
Globals.Assert(bufferrgn(l - 1).equals(synthwins.bufferrgn(l - 1)));
Window needed = windowCoarserLevel(bufferrgn(l - 1));
if (!(absValid(l).includes(needed)))
{
tobeupdated.Add(l);
ladded = true;
}
}
}
if (lpresent || ladded)
{
computeNewRegions(l, synthwins);
}
}
for (int l = 0; l < m_iNbLevels; l++)
{
if (l < lastsynthesizedlevel)
{
m_HasChanged[l] = false;
}
else if (!contains(ref tobeupdated, l))
{
Window absreq = synthwins.absRequested(l);
if (absreq.equals(absRequested(l)))
{
m_HasChanged[l] = false;
}
else
{
m_Requested[l] = absreq.relativeTo(bufferrgn(l));
m_UpdCopySrc[l] = new Window();
m_UpdCopyDst[l] = new Window();
m_UpdHorz[l] = new Window();
m_UpdVert[l] = new Window();
m_HasChanged[l] = true;
}
}
else
{
m_HasChanged[l] = true;
}
}
// sort list
sort(ref tobeupdated);
// sanity check
// -> check enough data in levels
for (int k = 0; k < tobeupdated.Count; k++)
{
if (tobeupdated[k] < m_iNbLevels - 1)
{
Window coarser_needed = windowCoarserLevel(bufferrgn(tobeupdated[k]));
Window coarser_valid = absValid(tobeupdated[k] + 1);
if (!coarser_valid.includes(coarser_needed))
{
// make sure parent also in regen
// cerr << "failed(" << (*R) << ") ";
MessageBox.Show("(SynthWindows::update) Sanity check failed !");
}
}
}
// cerr << endl;
// -> check list is sorted
int last = -1;
for (int k = 0; k < tobeupdated.Count; k++)
{
if (!(last == -1 || last > (tobeupdated[k])))
{
MessageBox.Show("(SynthWindows::update) List not sorted !");
}
last = tobeupdated[k];
}
return(tobeupdated);
}