← Back to branch summary

~ubuntu-branches/ubuntu/oneiric/nux/oneiric

« back to all changes in this revision

Viewing changes to NuxImage/ImageSurface.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Didier Roche
  • Date: 2010-12-09 19:56:53 UTC
  • mto: This revision was merged to the branch mainline in revision 6.
  • Revision ID: james.westby@ubuntu.com-20101209195653-lsc4objqdxs9exp3
Tags: upstream-0.9.10
Import upstream version 0.9.10

Show diffs side-by-side

added added

removed removed

Lines of Context:
NuxImage/ImageSurface.cpp
15
15
 * License version 3 along with this program.  If not, see
16
16
 * <http://www.gnu.org/licenses/>
17
17
 *
18
 
 * Authored by: Jay Taoko <jay.taoko_AT_gmail_DOT_com>
 
18
 * Authored by: Jay Taoko <jaytaoko@inalogic.com>
19
19
 *
20
20
 */
21
21
 
922
922
    NUX_RETURN_IF_FALSE (height_ != 0);
923
923
 
924
924
    ImageSurface temp (format_, width_, height_);
925
 
 
926
 
    int gauss_w = 1 + 2 * 3;          // Level(+1)
927
 
    int mask[7] = {1,6,15,20,15,6,1}; // Mask
928
 
    int gauss_sum = 64;               // Sum
929
 
 
930
 
    t_u8 R, G, B, A;
931
 
    double r = 0;
932
 
    double g = 0;
933
 
    double b = 0;
934
 
    double a = 0;
935
 
 
936
 
    // Horizontal blur
937
 
    for (int j = 0; j < height_ - 1; j++)
938
 
    {
939
 
      for (int i = gauss_w - 1; i < width_ - 1; i++)
940
 
      {
941
 
        r = 0;
942
 
        g = 0;
943
 
        b = 0;
944
 
        a = 0;
945
 
 
946
 
        for (int k = 0; k < gauss_w; k++)
947
 
        {
948
 
          int color = Read(i - (gauss_w-1) + k, j);
949
 
          R = NUX_RGBA_GET_RED (color);
950
 
          G = NUX_RGBA_GET_GREEN (color);
951
 
          B = NUX_RGBA_GET_BLUE (color);
952
 
          A = NUX_RGBA_GET_ALPHA (color);
953
 
 
954
 
          r += R * mask[k];
955
 
          g += G * mask[k];
956
 
          b += B * mask[k];
957
 
          a += A * mask[k];
958
 
        }
959
 
 
960
 
        R = r / gauss_sum;
961
 
        G = g / gauss_sum;
962
 
        B = b / gauss_sum;
963
 
        A = a / gauss_sum;
964
 
 
965
 
        temp.Write32b(i, j, NUX_RGBA (R, G, B, A));
966
 
      }
967
 
    }
968
 
 
969
 
    // Vertical blur
970
 
    for (int j = gauss_w - 1; j < height_ - 1; j++)
971
 
    {
972
 
      for (int i = 0; i < width_ - 1; i++)
973
 
      {
974
 
        r = 0;
975
 
        g = 0;
976
 
        b = 0;
977
 
        a = 0;
978
 
 
979
 
        for (int k = 0; k < gauss_w; k++)
980
 
        {
981
 
          int color = Read(i, j - (gauss_w-1) + k);
982
 
          R = NUX_RGBA_GET_RED (color);
983
 
          G = NUX_RGBA_GET_GREEN (color);
984
 
          B = NUX_RGBA_GET_BLUE (color);
985
 
          A = NUX_RGBA_GET_ALPHA (color);
986
 
 
987
 
          r += R * mask[k];
988
 
          g += G * mask[k];
989
 
          b += B * mask[k];
990
 
          a += A * mask[k];
991
 
        }
992
 
 
993
 
        R = r / gauss_sum;
994
 
        G = g / gauss_sum;
995
 
        B = b / gauss_sum;
996
 
        A = a / gauss_sum;
997
 
 
998
 
        Write32b(i, j, NUX_RGBA (R, G, B, A));
999
 
      }
1000
 
    }
 
925
 
 
926
    int gauss_w = 1 + 2 * 3;          // Level(+1)
 
927
    int mask[7] = {1,6,15,20,15,6,1}; // Mask
 
928
    int gauss_sum = 64;               // Sum
 
929
 
 
930
    t_u8 R, G, B, A;
 
931
    double r = 0;
 
932
    double g = 0;
 
933
    double b = 0;
 
934
    double a = 0;
 
935
 
 
936
    // Horizontal blur
 
937
    for (int j = 0; j < height_ - 1; j++)
 
938
    {
 
939
      for (int i = gauss_w - 1; i < width_ - 1; i++)
 
940
      {
 
941
        r = 0;
 
942
        g = 0;
 
943
        b = 0;
 
944
        a = 0;
 
945
 
 
946
        for (int k = 0; k < gauss_w; k++)
 
947
        {
 
948
          int color = Read(i - (gauss_w-1) + k, j);
 
949
          R = NUX_RGBA_GET_RED (color);
 
950
          G = NUX_RGBA_GET_GREEN (color);
 
951
          B = NUX_RGBA_GET_BLUE (color);
 
952
          A = NUX_RGBA_GET_ALPHA (color);
 
953
 
 
954
          r += R * mask[k];
 
955
          g += G * mask[k];
 
956
          b += B * mask[k];
 
957
          a += A * mask[k];
 
958
        }
 
959
 
 
960
        R = r / gauss_sum;
 
961
        G = g / gauss_sum;
 
962
        B = b / gauss_sum;
 
963
        A = a / gauss_sum;
 
964
 
 
965
        temp.Write32b(i, j, NUX_RGBA (R, G, B, A));
 
966
      }
 
967
    }
 
968
 
 
969
    // Vertical blur
 
970
    for (int j = gauss_w - 1; j < height_ - 1; j++)
 
971
    {
 
972
      for (int i = 0; i < width_ - 1; i++)
 
973
      {
 
974
        r = 0;
 
975
        g = 0;
 
976
        b = 0;
 
977
        a = 0;
 
978
 
 
979
        for (int k = 0; k < gauss_w; k++)
 
980
        {
 
981
          int color = Read(i, j - (gauss_w-1) + k);
 
982
          R = NUX_RGBA_GET_RED (color);
 
983
          G = NUX_RGBA_GET_GREEN (color);
 
984
          B = NUX_RGBA_GET_BLUE (color);
 
985
          A = NUX_RGBA_GET_ALPHA (color);
 
986
 
 
987
          r += R * mask[k];
 
988
          g += G * mask[k];
 
989
          b += B * mask[k];
 
990
          a += A * mask[k];
 
991
        }
 
992
 
 
993
        R = r / gauss_sum;
 
994
        G = g / gauss_sum;
 
995
        B = b / gauss_sum;
 
996
        A = a / gauss_sum;
 
997
 
 
998
        Write32b(i, j, NUX_RGBA (R, G, B, A));
 
999
      }
 
1000
    }
1001
1001
  }
1002
1002
 
1003
1003
  ///////////////////////////////////////////////////////////////////