31 #define c1 1 // best value 1
32 #define c2 2 // best value 2
58 UINT32 loWidth = width;
59 UINT32 hiWidth = width;
60 UINT32 loHeight = height;
61 UINT32 hiHeight = height;
63 for (
int level = 0; level <
m_nLevels; level++) {
68 hiWidth = loWidth >> 1; hiHeight = loHeight >> 1;
69 loWidth = (loWidth + 1) >> 1; loHeight = (loHeight + 1) >> 1;
87 ASSERT(level >= 0 && level <
m_nLevels - 1);
88 const int destLevel = level + 1;
91 const UINT32 width = srcBand->
GetWidth();
92 const UINT32 height = srcBand->
GetHeight();
94 UINT32 row0, row1, row2, row3;
99 if (!
m_subband[destLevel][i].AllocMemory())
return InsufficientMemory;
105 row0 = 0; row1 = width; row2 = row1 + width;
109 for (k=0; k < width; k++) {
110 src[row1] -= ((src[row0] + src[row2] +
c1) >> 1);
111 src[row0] += ((src[row1] +
c1) >> 1);
112 row0++; row1++; row2++;
118 for (i=3; i < height-1; i += 2) {
121 for (k=0; k < width; k++) {
122 src[row2] -= ((src[row1] + src[row3] +
c1) >> 1);
123 src[row1] += ((src[row0] + src[row2] +
c2) >> 2);
124 row0++; row1++; row2++; row3++;
127 row0 = row1; row1 = row2; row2 = row3; row3 += width;
132 for (k=0; k < width; k++) {
133 src[row1] += ((src[row0] +
c1) >> 1);
139 for (k=0; k < width; k++) {
140 src[row2] -= src[row1];
141 src[row1] += ((src[row0] + src[row2] +
c2) >> 2);
142 row0++; row1++; row2++;
148 row0 = 0; row1 = width;
150 for (k=0; k < height; k += 2) {
154 row0 += width << 1; row1 += width << 1;
187 src[1] -= ((src[0] + src[2] +
c1) >> 1);
188 src[0] += ((src[1] +
c1) >> 1);
191 for (; i < width-1; i += 2) {
192 src[i] -= ((src[i-1] + src[i+1] +
c1) >> 1);
193 src[i-1] += ((src[i-2] + src[i] +
c2) >> 2);
198 src[i-1] += ((src[i-2] +
c1) >> 1);
201 src[i-1] += ((src[i-2] + src[i] +
c2) >> 2);
209 const UINT32 wquot = width >> 1;
210 const bool wrem = width & 1;
216 for (i=0; i < wquot; i++) {
218 hl.WriteBuffer(*loRow++);
220 hh.WriteBuffer(*hiRow++);
227 for (i=0; i < wquot; i++) {
229 hl.WriteBuffer(*loRow++);
248 ASSERT(srcLevel > 0 && srcLevel <
m_nLevels);
249 const int destLevel = srcLevel - 1;
252 const UINT32 width = destBand->
GetWidth();
253 const UINT32 height = destBand->
GetHeight();
254 UINT32 row0, row1, row2, row3, i, k, origin = 0;
257 if (!destBand->
AllocMemory())
return InsufficientMemory;
260 #ifdef __PGFROISUPPORT__
261 const UINT32 srcLeft = (m_ROIs.ROIisSupported()) ? m_ROIs.Left(srcLevel) : 0;
262 const UINT32 srcTop = (m_ROIs.ROIisSupported()) ? m_ROIs.Top(srcLevel) : 0;
263 UINT32 destWidth = destBand->BufferWidth();
264 PGFRect destROI = (m_ROIs.ROIisSupported()) ? m_ROIs.GetROI(destLevel) :
PGFRect(0, 0, width, height);
265 destROI.
right = destROI.
left + destWidth;
267 UINT32 destHeight = destROI.
Height();
270 if (destROI.
left & 1) {
275 if (destROI.
top & 1) {
282 UINT32 left = destROI.
left >> 1;
283 UINT32 top = destROI.
top >> 1;
291 PGFRect destROI(0, 0, width, height);
292 const UINT32 destWidth = width;
293 const UINT32 destHeight = height;
303 row0 = origin; row1 = row0 + destWidth;
305 for (k=0; k < destWidth; k++) {
306 ASSERT(row0 < destBand->m_size);
307 ASSERT(row1 < destBand->m_size);
308 dest[row0] -= ((dest[row1] +
c1) >> 1);
313 row2 = row1; row1 = row0; row0 = row0 - destWidth; row3 = row2 + destWidth;
314 for (i=destROI.
top + 2; i < destROI.
bottom - 1; i += 2) {
316 for (k=0; k < destWidth; k++) {
317 ASSERT(row0 < destBand->m_size);
318 ASSERT(row1 < destBand->m_size);
319 ASSERT(row2 < destBand->m_size);
320 ASSERT(row3 < destBand->m_size);
321 dest[row2] -= ((dest[row1] + dest[row3] +
c2) >> 2);
322 dest[row1] += ((dest[row0] + dest[row2] +
c1) >> 1);
323 row0++; row1++; row2++; row3++;
325 InverseRow(&dest[row0 - destWidth], destWidth);
326 InverseRow(&dest[row1 - destWidth], destWidth);
327 row0 = row1; row1 = row2; row2 = row3; row3 += destWidth;
331 if (destHeight & 1) {
333 for (k=0; k < destWidth; k++) {
334 ASSERT(row0 < destBand->m_size);
335 ASSERT(row1 < destBand->m_size);
336 ASSERT(row2 < destBand->m_size);
337 dest[row2] -= ((dest[row1] +
c1) >> 1);
338 dest[row1] += ((dest[row0] + dest[row2] +
c1) >> 1);
339 row0++; row1++; row2++;
341 InverseRow(&dest[row0 - destWidth], destWidth);
342 InverseRow(&dest[row1 - destWidth], destWidth);
343 InverseRow(&dest[row2 - destWidth], destWidth);
345 for (k=0; k < destWidth; k++) {
346 ASSERT(row0 < destBand->m_size);
347 ASSERT(row1 < destBand->m_size);
348 dest[row1] += dest[row0];
351 InverseRow(&dest[row0 - destWidth], destWidth);
352 InverseRow(&dest[row1 - destWidth], destWidth);
356 row0 = origin; row1 = row0 + destWidth;
358 for (k=0; k < destHeight; k += 2) {
362 row0 += destWidth << 1; row1 += destWidth << 1;
365 if (destHeight & 1) {
392 dest[0] -= ((dest[1] +
c1) >> 1);
395 for (; i < width - 1; i += 2) {
396 dest[i] -= ((dest[i-1] + dest[i+1] +
c2) >> 2);
397 dest[i-1] += ((dest[i-2] + dest[i] +
c1) >> 1);
402 dest[i] -= ((dest[i-1] +
c1) >> 1);
403 dest[i-1] += ((dest[i-2] + dest[i] +
c1) >> 1);
405 dest[i-1] += dest[i-2];
413 const UINT32 wquot = width >> 1;
414 const bool wrem = width & 1;
420 #ifdef __PGFROISUPPORT__
421 const bool storePos = wquot < ll.BufferWidth();
422 UINT32 llPos = 0, hlPos = 0, lhPos = 0, hhPos = 0;
427 hlPos = hl.GetBuffPos();
429 hhPos = hh.GetBuffPos();
433 for (i=0; i < wquot; i++) {
435 *loRow++ = hl.ReadBuffer();
437 *hiRow++ = hh.ReadBuffer();
445 #ifdef __PGFROISUPPORT__
448 ll.IncBuffRow(llPos);
449 hl.IncBuffRow(hlPos);
450 lh.IncBuffRow(lhPos);
451 hh.IncBuffRow(hhPos);
456 #ifdef __PGFROISUPPORT__
457 const bool storePos = wquot < ll.BufferWidth();
458 UINT32 llPos = 0, hlPos = 0;
463 hlPos = hl.GetBuffPos();
467 for (i=0; i < wquot; i++) {
469 *loRow++ = hl.ReadBuffer();
473 #ifdef __PGFROISUPPORT__
476 ll.IncBuffRow(llPos);
477 hl.IncBuffRow(hlPos);
483 #ifdef __PGFROISUPPORT__
487 void CWaveletTransform::SetROI(
const PGFRect& rect) {
492 m_ROIs.CreateIndices();
502 const PGFRect& indices = m_ROIs.GetIndices(i);
515 void CWaveletTransform::SetROI() {
532 void CROIs::CreateROIs() {
540 void CROIs::CreateIndices() {
554 void CROIs::ComputeTileIndex(UINT32 width, UINT32 height, UINT32 pos,
bool horizontal,
bool isMin) {
558 UINT32 tileIndex = 0;
559 UINT32 tileMin = 0, tileMax = (horizontal) ? width : height;
560 ASSERT(pos <= tileMax);
563 for (
int i=m_nLevels - 1; i >= 0; i--) {
567 m_indices[i].left = tileIndex;
569 m_indices[i].right = tileIndex + 1;
573 m_indices[i].top = tileIndex;
575 m_indices[i].bottom = tileIndex + 1;
581 m = (tileMin + tileMax)/2;
596 void CROIs::ComputeIndices(UINT32 width, UINT32 height,
const PGFRect& rect) {
597 ComputeTileIndex(width, height, rect.
left,
true,
true);
598 ComputeTileIndex(width, height, rect.
top,
false,
true);
599 ComputeTileIndex(width, height, rect.
right,
true,
false);
600 ComputeTileIndex(width, height, rect.
bottom,
false,
false);
603 #endif // __PGFROISUPPORT__