Dynamische Arrays

[Garfield]

Die letzte Schleife habe ich nun geändert nach:

Code:

for (w = 0; w < maskWidth * 3; w += 3)
{
   *(dstp + minW + w)     = (blurR[w / 3 + radius + 1] - blurR[w / 3 + radius]) / (radius * 2 + 1); 
   *(dstp + minW + w + 1) = (blurG[w / 3 + radius + 1] - blurG[w / 3 + radius]) / (radius * 2 + 1); 
   *(dstp + minW + w + 2) = (blurB[w / 3 + radius + 1] - blurB[w / 3 + radius]) / (radius * 2 + 1);
}

Die / 3 hatte ich vergessen. Durch die Bereichsänderung ist es aber kein senkrechter Strich mehr sondern das Zielrechteck steht rechts neben dem Quellrechteck.

Es scheint an den Pointern in diesem Bereich zu liegen:

Code:

if (minW = (w - radius * 3))
{
   blurB[0] = *(dstp + tmp);
   blurG[0] = *(dstp + tmp + 1);
   blurR[0] = *(dstp + tmp + 2);
}
else
{
   blurB[w / 3] = blurB[(w / 3) - 1] + *(dstp + tmp);
   blurG[w / 3] = blurG[(w / 3) - 1] + *(dstp + tmp + 1);  
   blurR[w / 3] = blurR[(w / 3) - 1] + *(dstp + tmp + 2);
}

Es soll der Farbwert von *(dstp + tmp) nach blurB[0] usw übertragen werden. Wenn ich den Bereich auskommentiere, liegen die Rechtecke übereinander.

Gauss funktioniert:

Code:

const unsigned int matrix[25] = {1, 4, 7, 4, 1, 4, 16, 26, 16, 1, 7, 26, 41, 26, 7, 4, 16, 26, 16, 4, 1, 4, 7, 4, 1};
   
int w, h, mw, mh, rp;
int minW, maxW, minH, maxH;

unsigned int blurR, blurG, blurB;
unsigned int idx;
unsigned int count;

minH = vi.height - maskTop - maskHeight;
maxH = vi.height - maskTop - 1;
minW = maskLeft * 3;
maxW = (maskLeft + maskWidth - 1)  * 3;
      
for (rp = 0; rp < replays; rp ++)
{
   dstp = dst->GetWritePtr();
   dstp = dstp + (minH * dst_pitch); 

   for (h = minH; h < maxH; h ++) 
   {   
      for (w = minW; w < maxW; w += 3)
      {
         blurR = 0;
         blurG = 0;
         blurB = 0;
         count = 0;

         for (mh = -2; mh < +2; mh ++)
         {
            for (mw = -6; mw < +6; mw += 3)
            {
               if ((0 <= h + mh) && (h + mh < dst_height) && (0 <= w + mw) && (w + mw < dst_width))
               {
                  idx = (mh + 2) * 5 + abs((int)((mw + 6) / 3));
                  count = count + matrix[idx];
                  blurR = blurR + (*(dstp + w + (mw * dst_pitch)) * matrix[idx]);
                  blurG = blurG + (*(dstp + w + (mw * dst_pitch) + 1) * matrix[idx]);
                  blurB = blurB + (*(dstp + w + (mw * dst_pitch) + 2) * matrix[idx]);
               }
            }
         }
         if (count > 0)
         {
            *(dstp + w)     = blurR / count;  // Blauwert eintragen.      
            *(dstp + w + 1) = blurG / count;  // Grünwert eintragen. 
             *(dstp + w + 2) = blurB / count;  // Rotwert eintragen.
         }
      }
      dstp = dstp + dst_pitch;
   }
}

Allerdings sind hier blurR, blurG und blurB vom Typ Int. Oben wegen den Array int*. Ein

Code:

blurB[0] = (int)*(dstp + tmp);

bringt leider auch nichts.