agg/source/agg_image_filters.cpp

   1 //----------------------------------------------------------------------------
   2 // Anti-Grain Geometry - Version 2.3
   3 // Copyright (C) 2002-2005 Maxim Shemanarev (http://www.antigrain.com)
   4 //
   5 // Permission to copy, use, modify, sell and distribute this software
   6 // is granted provided this copyright notice appears in all copies.
   7 // This software is provided "as is" without express or implied
   8 // warranty, and with no claim as to its suitability for any purpose.
   9 //
  10 //----------------------------------------------------------------------------
  11 // Contact: mcseem@antigrain.com
  12 //          mcseemagg@yahoo.com
  13 //          http://www.antigrain.com
  14 //----------------------------------------------------------------------------
  15 //
  16 // Filtering class image_filter_lut implemantation
  17 //
  18 //----------------------------------------------------------------------------
  19
  20
  21 #include "agg_image_filters.h"
  22
  23
  24 namespace agg
  25 {
  26
  27     //--------------------------------------------------------------------
  28     image_filter_lut::~image_filter_lut()
  29     {
  30         delete [] m_weight_array;
  31     }
  32
  33
  34     //--------------------------------------------------------------------
  35     image_filter_lut::image_filter_lut() :
  36         m_weight_array(0),
  37         m_max_size(0)
  38     {}
  39
  40     //--------------------------------------------------------------------
  41     void image_filter_lut::realloc(double _radius)
  42     {
  43         m_radius = _radius;
  44         m_diameter = unsigned(ceil(_radius)) * 2;
  45         m_start = -int(m_diameter / 2 - 1);
  46         unsigned size = m_diameter << image_subpixel_shift;
  47         if(size > m_max_size)
  48         {
  49             delete [] m_weight_array;
  50             m_weight_array = new int16 [size];
  51             m_max_size = size;
  52         }
  53     }
  54
  55
  56
  57     //--------------------------------------------------------------------
  58     // This function normalizes integer values and corrects the rounding
  59     // errors. It doesn't do anything with the source floating point values
  60     // (m_weight_array_dbl), it corrects only integers according to the rule
  61     // of 1.0 which means that any sum of pixel weights must be equal to 1.0.
  62     // So, the filter function must produce a graph of the proper shape.
  63     //--------------------------------------------------------------------
  64     void image_filter_lut::normalize()
  65     {
  66         unsigned i;
  67         int flip = 1;
  68
  69         for(i = 0; i < image_subpixel_size; i++)
  70         {
  71             for(;;)
  72             {
  73                 int sum = 0;
  74                 unsigned j;
  75                 for(j = 0; j < m_diameter; j++)
  76                 {
  77                     sum += m_weight_array[j * image_subpixel_size + i];
  78                 }
  79
  80                 if(sum == image_filter_size) break;
  81
  82                 double k = double(image_filter_size) / double(sum);
  83                 sum = 0;
  84                 for(j = 0; j < m_diameter; j++)
  85                 {
  86                     sum += m_weight_array[j * image_subpixel_size + i] =
  87                         int16(m_weight_array[j * image_subpixel_size + i] * k);
  88                 }
  89
  90                 sum -= image_filter_size;
  91                 int16 inc = (sum > 0) ? -1 : 1;
  92
  93                 for(j = 0; j < m_diameter && sum; j++)
  94                 {
  95                     flip ^= 1;
  96                     unsigned idx = flip ? m_diameter/2 + j/2 : m_diameter/2 - j/2;
  97                     int v = m_weight_array[idx * image_subpixel_size + i];
  98                     if(v < image_filter_size)
  99                     {
 100                         m_weight_array[idx * image_subpixel_size + i] =
 101                             m_weight_array[idx * image_subpixel_size + i] + inc;
 102                         sum += inc;
 103                     }
 104                 }
 105             }
 106         }
 107
 108         unsigned pivot = m_diameter << (image_subpixel_shift - 1);
 109
 110         for(i = 0; i < pivot; i++)
 111         {
 112             m_weight_array[pivot + i] = m_weight_array[pivot - i];
 113         }
 114         unsigned end = (diameter() << image_subpixel_shift) - 1;
 115         m_weight_array[0] = m_weight_array[end];
 116     }
 117
 118
 119 }
 120