1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:

unsigned char cvhFractileFilterHelper(IplImage *src, const int k, const int l, const int n, const int m, 
  const int percentile)
{
  priority_queue<unsigned char> L;

  // evaluate neighboor field
  for (int y = max(l - m, 0); y <= min(l + m, src->height - 1); y++)
  {
    for (int x = max(k - n, 0); x <= min(k + n, src->width - 1); x++)
    {
      if ((x != k) || (l != y))
      {
        L.push((unsigned char) src->imageData[y * src->widthStep + x]);
      }
    }
  }

  // return pixel within the desired percentile
  int res = 0;
  int max = floor(((100 - percentile) * L.size() / 100.0) + 0.5);
  for (int i = 1; i < max; i++)
  {
    res = L.top();
    L.pop();
  }
  return res;
}

void cvhFractileFilter(IplImage *src, IplImage *dst, const int n, const int m, 
  const int percentile)
{
  if ((!cvhCheckGrayscale(src)) || (!cvhCheckIfSameProperties(src, dst)) ||
    (n < 1) || (m < 1) || (percentile < 0) || (percentile > 100))
    return;

  for (int y = 0; y < src->height; y++)
  {
    for (int x = 0; x < src->width; x++)
    {
      dst->imageData[x + y * dst->widthStep] =
        (char) cvhFractileFilterHelper(src, x, y, n, m, percentile);
    }
  }
}					

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:

void cvhFractileFilter(IplImage *src, IplImage *dst, const int n, const int m, 
  const int percentile, const int passes)
{
  if ((!cvhCheckGrayscale(src)) || (!cvhCheckIfSameProperties(src, dst)) ||
    (n < 1) || (m < 1) || (percentile < 0) || (percentile > 100) || (passes < 1))
    return;

  // array with neighboor pixels
  vector<unsigned char> L;
  L.resize((2*n+1)*(2*m+1) - 1);

  for (int p = 0; p < passes; p++)
  {
    // cykle through all columns
    for (int y = 0; y < src->height; y++)
    {
      // calculate column pixel offset
      int col = y * src->widthStep;
      // cykle through all rows
      for (int x = 0; x < src->width; x++)
      {
        // evaluate window
        // empty array
        L.clear();
        // cykle through all window rows
        int wsize_y = min(y + m, src->height - 1);
        for (int wy = max(y - m, 0); wy <= wsize_y; wy++)
        {
          // calculate window column pixel offset
          int wcol = wy * src->widthStep;
          // cykle through all window columns
          int wsize_x = min(x + n, src->width - 1);
          for (int wx = max(x - n, 0); wx <= wsize_x; wx++)
          {
            // check whether window pixel differs from center pixel
            if ((wx != x) || (wy != y))
            {
              L.push_back(src->imageData[wcol + wx]);
            }
          }
        }
        sort(L.begin(), L.end());
        int i = min((int) ((100 - percentile) * L.size() / 100.0), (int) L.size() - 1);
        dst->imageData[col + x] = (char) L[i];
      }
    }
  }
}					

1:
2:
3:
4:
5:

for(int i = 1; i <= w; i++) {
    for(int j = 1; j <= h; j++) {
        p[j, i] = (int)(((100-percentile)*(i*j-1))/100.0); //Index für Zugriff
    }
}