---

/home/landauf/painter/miniproject/image/imagergba.cpp

Go to the documentation of this file.

//
//    Title: imagergba.cc
//  Created: Tue Oct  2 19:03:11 2001
//   Author: Tim Weyrich <weyrich@inf.ethz.ch>
//
// copyright (c) 2001--2003, Computer Graphics Laboratory, ETH Zuerich
//

#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include <iostream>
#include <math.h>

#include "imagergba.h"
#include "clip.h"

#include <tiff.h>
#include <tiffio.h>

#define  HAVE_BIGENDIAN  (*(unsigned short *)"12" == 0x3132)

#define  SWAP_UINT32(x)  (( ((unsigned long)(x) << 24) |  ((((unsigned long)(x)) & 0x0000ff00UL) <<  8) |  ((((unsigned long)(x)) & 0x00ff0000UL) >>  8) |  ( ((unsigned long)(x)) >> 24)))
/*
Rgba::Rgba(unsigned char _r, unsigned char _g, unsigned char _b, unsigned char _a)
{
    r = _r;
    g = _g;
    b = _b;
    a = _a;
}

void Rgba::set(unsigned char _r, unsigned char _g, unsigned char _b, unsigned char _a)
{
    r = _r;
    g = _g;
    b = _b;
    a = _a;
}*/


ImageRGBA  *imageRgbaNew(int width, int height)
{
  ImageRGBA  *result = NULL;
  
  assert(width >= 0);
  assert(height >= 0);

  result = (ImageRGBA *)malloc(sizeof(ImageRGBA));
  result->width = width;
  result->height = height;
  result->bytesPerPixel = 4;
  result->data = (Rgba *)malloc(width * height * sizeof(Rgba));

  return result;
}

void  imageRgbaFree(ImageRGBA *img)
{
  assert(img->bytesPerPixel == sizeof(Rgba));
  delete img->data;
  delete img;
}

// ----------------------------------------------------------------------------

ImageRGBA  *imageRgbaClone(const ImageRGBA *img)
{
  assert(img->bytesPerPixel == sizeof(Rgba));
  
  ImageRGBA  *result = imageRgbaNew(img->width, img->height);

  if (result)
    memcpy(result->data, img->data, img->width * img->height * sizeof(Rgba));
  
  return result;
}


// ----------------------------------------------------------------------------

void  imageRgbaCopy(const ImageRGBA *src, const ImageRGBA *dest)
{
  assert(src->height == dest->height && src->width == dest->width);
  
  memcpy(dest->data, src->data, src->width * src->height * sizeof(Rgba));
 
}


void  imageRgbaClear(ImageRGBA *img)
{
  assert(img->bytesPerPixel == sizeof(Rgba));
  imageRgbaSet(img, 255, 255, 255, 255);
}

void  imageRgbaSet(ImageRGBA *img,
                   unsigned r, unsigned g, unsigned b, unsigned a)
{
  assert(img->bytesPerPixel == sizeof(Rgba));
  
  Rgba   val = {r, g, b, a};
  Rgba  *p, *e = img->data + img->width * img->height;

  for (p=img->data; p<e; *p++=val);
}

void imageRgbaSetArea(ImageRGBA *img, int x0, int y0, int x1, int y1, Rgba color)
{
    for (int y = y0; y < y1; y++)
    {
        for (int x = x0; x < x1; x++)
        {
            img->data[x + img->width * y] = color;
        }
    }
}


ImageRGBA  *imageRgbaReadTIFF(const char *fname)
{
  TIFF  *tif;
  if ((tif = TIFFOpen(fname, "r")) != NULL)
    {
      ImageRGBA  *result = NULL;
      uint32      width, height;

      TIFFGetField(tif, TIFFTAG_IMAGEWIDTH, &width);
      TIFFGetField(tif, TIFFTAG_IMAGELENGTH, &height);
      
      if ((result = imageRgbaNew(width, height)) != NULL)
        {
          if (TIFFReadRGBAImage(tif, result->width, result->height, (uint32 *)result->data, 0))
            { /* success -- flip image and eventually twiddle bytes
                 (watch out: I'm doing dirty tricks, assuming a
                 special memory layout of struct Rgba) */
              unsigned long  *p, *q, temp;
              int             c;
              
              if (HAVE_BIGENDIAN)
                {
                  for (p=(unsigned long *)result->data,
                         q=(unsigned long *)result->data+(result->height-1)*result->width;
                       p < q;
                       p+=result->width, q-=result->width)
                    for (c=result->width-1; c>=0; c--)
                      {
                        temp=p[c];
                        p[c]=SWAP_UINT32(q[c]);
                        q[c]=SWAP_UINT32(temp);
                      }
                  
                  if (p == q)
                    for (c=result->width-1; c>=0; c--)
                      { p[c]=SWAP_UINT32(p[c]); }
                }
              else
                {
                  unsigned long  *p, *q, temp;
                  int             c;
                  for (p=(unsigned long *)result->data,
                         q=(unsigned long *)result->data+(result->height-1)*result->width;
                       p < q;
                       p+=result->width, q-=result->width)
                    for (c=result->width-1; c>=0; c--)
                      {
                        temp=p[c];
                        p[c]=q[c];
                        q[c]=temp;
                      }
                }
            }
          else
            {
              imageRgbaFree(result);
//              TIFFClose(tif);
              result = NULL;
            }
        }

      TIFFClose(tif);
      return result;
    }
  
  return NULL;
}

int  imageRgbaWriteTIFF(const char *fname, const ImageRGBA *img)
{
  assert(img->bytesPerPixel == sizeof(Rgba));
  
  TIFF  *tif;
  if ((tif = TIFFOpen(fname, "w")) != NULL)
    {
      int  y;

      TIFFSetField(tif, TIFFTAG_SUBFILETYPE, 0);
      TIFFSetField(tif, TIFFTAG_IMAGEWIDTH, img->width);
      TIFFSetField(tif, TIFFTAG_IMAGELENGTH, img->height);
      TIFFSetField(tif, TIFFTAG_SAMPLESPERPIXEL, 4);
      TIFFSetField(tif, TIFFTAG_BITSPERSAMPLE, 8, 8, 8, 8);
      TIFFSetField(tif, TIFFTAG_COMPRESSION, COMPRESSION_PACKBITS);
      TIFFSetField(tif, TIFFTAG_PHOTOMETRIC, PHOTOMETRIC_RGB);
      TIFFSetField(tif, TIFFTAG_DOCUMENTNAME, fname);
      TIFFSetField(tif, TIFFTAG_IMAGEDESCRIPTION, "Created With My Personal Painter Application :-)");
      TIFFSetField(tif, TIFFTAG_ORIENTATION, ORIENTATION_TOPLEFT);
      TIFFSetField(tif, TIFFTAG_ROWSPERSTRIP, 64);
      TIFFSetField(tif, TIFFTAG_XRESOLUTION, 75.0);
      TIFFSetField(tif, TIFFTAG_YRESOLUTION, 75.0);
      TIFFSetField(tif, TIFFTAG_PLANARCONFIG, PLANARCONFIG_CONTIG);
      TIFFSetField(tif, TIFFTAG_RESOLUTIONUNIT, RESUNIT_INCH);

      for (y=0; y<img->height; y++)
        if (TIFFWriteScanline(tif, img->data+y*img->width, y, 0) < 0)
          break;

      if (y < img->height)
        {
          //cerr << "Error while writing to TIFF file." << endl;
          TIFFClose(tif);
          return 1;
        }
      else
        {
          TIFFClose(tif);
          return 0;
        }
    }
  else
    //cerr << "Couldn't open `" << fname << "' for writing." << endl;
  
  return 1;
}


void  imageRgbaDrawLine (ImageRGBA *img, int x0, int y0, int x1, int y1, Rgba colorValue, int lx0, int ly0, int lx1, int ly1)
{
  if (lx1 == -1)
    lx1 = img->width;
  if (ly1 == -1)
    ly1 = img->height;
    
  // clip line
  {
    float  x[2] = {(float)x0, (float)x1};
    float  y[2] = {(float)y0, (float)y1};

    if (clip(x, y, 0, 0, (float)img->width-1, (float)img->height-1) == 2)
      return;

    x0 = (int)floor(x[0] + 0.5);
    y0 = (int)floor(y[0] + 0.5);
    x1 = (int)floor(x[1] + 0.5);
    y1 = (int)floor(y[1] + 0.5);
  }
  
  // starting point of line
  int x = x0, y = y0;

  // direction of line
  int dx = x1-x0, dy = y1-y0;

  // increment or decrement depending on direction of line
  int sx = (dx > 0 ? 1 : (dx < 0 ? -1 : 0));
  int sy = (dy > 0 ? 1 : (dy < 0 ? -1 : 0));

  // decision parameters for voxel selection
  if ( dx < 0 ) dx = -dx;
  if ( dy < 0 ) dy = -dy;
  int ax = 2*dx, ay = 2*dy;
  int decx, decy;

  // determine largest direction component, single-step related variable
  int max = dx, var = 0;
  if ( dy > max ) { var = 1; }

  // traverse Bresenham line
  switch ( var )
    {
    case 0:  // single-step in x-direction
      for (decy=ay-dx; ; x += sx, decy += ay)
        {
          // process pixel
          if (x >= lx0 && x <= lx1 && y >= ly0 && y <= ly1)
              img->data[x + y*img->width] = colorValue;

          // take Bresenham step
          if ( x == x1 ) break;
          if ( decy >= 0 ) { decy -= ax; y += sy; }
        }
      break;
    case 1:  // single-step in y-direction
      for (decx=ax-dy; ; y += sy, decx += ax)
        {
          // process pixel
          if (x >= lx0 && x <= lx1 && y >= ly0 && y <= ly1)
              img->data[x + y*img->width] = colorValue;

          // take Bresenham step
          if ( y == y1 ) break;
          if ( decx >= 0 ) { decx -= ay; x += sx; }
        }
      break;
    }
}


void  imageRgbaInvertLine(ImageRGBA *img, int x0, int y0, int x1, int y1, int lx0, int ly0, int lx1, int ly1)
{
  if (lx1 == -1)
    lx1 = img->width;
  if (ly1 == -1)
    ly1 = img->height;
    
  // clip line
  {
    float  x[2] = {(float)x0, (float)x1};
    float  y[2] = {(float)y0, (float)y1};

    if (clip(x, y, 0.0f, 0.0f, (float)(img->width-1), (float)(img->height-1)) == 2)
      return;

    x0 = (int)floor(x[0] + 0.5);
    y0 = (int)floor(y[0] + 0.5);
    x1 = (int)floor(x[1] + 0.5);
    y1 = (int)floor(y[1] + 0.5);
  }
  
  // starting point of line
  int x = x0, y = y0;

  // direction of line
  int dx = x1-x0, dy = y1-y0;

  // increment or decrement depending on direction of line
  int sx = (dx > 0 ? 1 : (dx < 0 ? -1 : 0));
  int sy = (dy > 0 ? 1 : (dy < 0 ? -1 : 0));

  // decision parameters for voxel selection
  if ( dx < 0 ) dx = -dx;
  if ( dy < 0 ) dy = -dy;
  int ax = 2*dx, ay = 2*dy;
  int decx, decy;

  // determine largest direction component, single-step related variable
  int max = dx, var = 0;
  if ( dy > max ) { var = 1; }

  // traverse Bresenham line
  switch ( var )
    {
    case 0:  // single-step in x-direction
      for (decy=ay-dx; ; x += sx, decy += ay)
        {
          // process pixel
          if (x >= lx0 && x <= lx1 && y >= ly0 && y <= ly1)
          {
              img->data[x + y*img->width].r = 255 - img->data[x + y*img->width].r;
              img->data[x + y*img->width].g = 255 - img->data[x + y*img->width].g;
              img->data[x + y*img->width].b = 255 - img->data[x + y*img->width].b;
          }

          // take Bresenham step
          if ( x == x1 ) break;
          if ( decy >= 0 ) { decy -= ax; y += sy; }
        }
      break;
    case 1:  // single-step in y-direction
      for (decx=ax-dy; ; y += sy, decx += ax)
        {
          // process pixel
          if (x >= lx0 && x <= lx1 && y >= ly0 && y <= ly1)
          {
              img->data[x + y*img->width].r = 255 - img->data[x + y*img->width].r;
              img->data[x + y*img->width].g = 255 - img->data[x + y*img->width].g;
              img->data[x + y*img->width].b = 255 - img->data[x + y*img->width].b;
          }

          // take Bresenham step
          if ( y == y1 ) break;
          if ( decx >= 0 ) { decx -= ay; x += sx; }
        }
      break;
    }
}


void imageRgbaDrawHorizontalAreaLine(ImageRGBA *img, int x0, int x1, int y, int colorOffset)
{
    char color;
    int location;
    for (int x = x1; x >= x0; x--)
    {
        if ((colorOffset % 8) < 4)
            color = 0;
        else
            color = 255;
        
        location = x + img->width * y;
        img->data[location].r = color;
        img->data[location].g = color;
        img->data[location].b = color;
        img->data[location].a = 255;
        colorOffset++;
    }
}

void imageRgbaDrawVerticalAreaLine(ImageRGBA *img, int y0, int y1, int x, int colorOffset)
{
    char color;
    int location;
    for (int y = y1; y >= y0; y--)
    {
        if ((colorOffset % 8) < 4)
            color = 0;
        else
            color = 255;

        location = x + img->width * y;
        img->data[location].r = color;
        img->data[location].g = color;
        img->data[location].b = color;
        img->data[location].a = 255;
        colorOffset++;
    }
}


/* draw ellipse incrementally using Bresenham's algorithm */
void  imageRgbaDrawEllipse(ImageRGBA *img, int cx, int cy, int halfaxis_x, int halfaxis_y, Rgba colorValue, int lx0, int ly0, int lx1, int ly1)
{
    if (lx1 == -1)
        lx1 = img->width;
    if (ly1 == -1)
        ly1 = img->height;
        
        halfaxis_x = abs(halfaxis_x);

        /* intermediate terms to speed up loop */
        long t1 = halfaxis_x*halfaxis_x, t2 = t1<<1, t3 = t2<<1;
        long t4 = halfaxis_y*halfaxis_y, t5 = t4<<1, t6 = t5<<1;
        long t7 = halfaxis_x*t5, t8 = t7<<1, t9 = 0L;
        long d1 = t2 - t7 + (t4>>1);    /* error terms */
        long d2 = (t1>>1) - t8 + t5;

        int x = halfaxis_x, y = 0;      /* ellipse points */

        while (d2 < 0)                  /* til slope = -1 */
        {
                /* draw 4 points using symmetry */
        if ((cx + x) >= lx0 && (cx + x) <= lx1 && (cy + y) >= ly0 && (cy + y) <= ly1)
            imageRgbaDrawPoint(img, cx + x, cy + y, colorValue);
        if ((cx + x) >= lx0 && (cx + x) <= lx1 && (cy - y) >= ly0 && (cy - y) <= ly1)
            imageRgbaDrawPoint(img, cx + x, cy - y, colorValue);
        if ((cx - x) >= lx0 && (cx - x) <= lx1 && (cy + y) >= ly0 && (cy + y) <= ly1)
            imageRgbaDrawPoint(img, cx - x, cy + y, colorValue);
        if ((cx - x) >= lx0 && (cx - x) <= lx1 && (cy - y) >= ly0 && (cy - y) <= ly1)
            imageRgbaDrawPoint(img, cx - x, cy - y, colorValue);

                y++;            /* always move up here */
                t9 += t3;       
                if (d1 < 0)     /* move straight up */
                {
                        d1 += t9 + t2;
                        d2 += t9;
                }
                else            /* move up and left */
                {
                        x--;
                        t8 -= t6;
                        d1 += t9 + t2 - t8;
                        d2 += t9 + t5 - t8;
                }
        }

        while (x >= 0)                          /* rest of top right quadrant */
        {
                /* draw 4 points using symmetry */
        if ((cx + x) >= lx0 && (cx + x) <= lx1 && (cy + y) >= ly0 && (cy + y) <= ly1)
            imageRgbaDrawPoint(img, cx + x, cy + y, colorValue);
        if ((cx + x) >= lx0 && (cx + x) <= lx1 && (cy - y) >= ly0 && (cy - y) <= ly1)
            imageRgbaDrawPoint(img, cx + x, cy - y, colorValue);
        if ((cx - x) >= lx0 && (cx - x) <= lx1 && (cy + y) >= ly0 && (cy + y) <= ly1)
            imageRgbaDrawPoint(img, cx - x, cy + y, colorValue);
        if ((cx - x) >= lx0 && (cx - x) <= lx1 && (cy - y) >= ly0 && (cy - y) <= ly1)
            imageRgbaDrawPoint(img, cx - x, cy - y, colorValue);

                x--;            /* always move left here */
                t8 -= t6;       
                if (d2 < 0)     /* move up and left */
                {
                        y++;
                        t9 += t3;
                        d2 += t9 + t5 - t8;
                }
                else            /* move straight left */
                        d2 += t5 - t8;
        } 
}


/* draw ellipse incrementally using Bresenham's algorithm */
void  imageRgbaInvertEllipse(ImageRGBA *img, int cx, int cy, int halfaxis_x, int halfaxis_y)
{
        halfaxis_x = abs(halfaxis_x);
        
        /* intermediate terms to speed up loop */
        long t1 = halfaxis_x*halfaxis_x, t2 = t1<<1, t3 = t2<<1;
        long t4 = halfaxis_y*halfaxis_y, t5 = t4<<1, t6 = t5<<1;
        long t7 = halfaxis_x*t5, t8 = t7<<1, t9 = 0L;
        long d1 = t2 - t7 + (t4>>1);    /* error terms */
        long d2 = (t1>>1) - t8 + t5;

        int x = halfaxis_x, y = 0;      /* ellipse points */

        while (d2 < 0)                  /* til slope = -1 */
        {
                /* draw 4 points using symmetry */
                imageRgbaDrawInvertedPoint(img, cx + x, cy + y);
            imageRgbaDrawInvertedPoint(img, cx + x, cy - y);
            imageRgbaDrawInvertedPoint(img, cx - x, cy + y);
            imageRgbaDrawInvertedPoint(img, cx - x, cy - y);

                y++;            /* always move up here */
                t9 += t3;       
                if (d1 < 0)     /* move straight up */
                {
                        d1 += t9 + t2;
                        d2 += t9;
                }
                else            /* move up and left */
                {
                        x--;
                        t8 -= t6;
                        d1 += t9 + t2 - t8;
                        d2 += t9 + t5 - t8;
                }
        }

        while (x >= 0)                          /* rest of top right quadrant */
        {
                /* draw 4 points using symmetry */
                imageRgbaDrawInvertedPoint(img, cx + x, cy + y);
            imageRgbaDrawInvertedPoint(img, cx + x, cy - y);
            imageRgbaDrawInvertedPoint(img, cx - x, cy + y);
            imageRgbaDrawInvertedPoint(img, cx - x, cy - y);

                x--;            /* always move left here */
                t8 -= t6;       
                if (d2 < 0)     /* move up and left */
                {
                        y++;
                        t9 += t3;
                        d2 += t9 + t5 - t8;
                }
                else            /* move straight left */
                        d2 += t5 - t8;
        } 
}


inline void  imageRgbaDrawPoint(ImageRGBA *img, int x, int y, Rgba colorValue)
{
        // process pixel
        if (x >= 0 && y >= 0 && x < img->width && y < img->height) {    
        img->data[x + y*img->width] = colorValue;
        }
}


inline void  imageRgbaDrawInvertedPoint(ImageRGBA *img, int x, int y)
{
        // process pixel
        if (x >= 0 && y >= 0 && x < img->width && y < img->height) {    
        img->data[x + y*img->width].r = 255 - img->data[x + y*img->width].r;
        img->data[x + y*img->width].g = 255 - img->data[x + y*img->width].g;
        img->data[x + y*img->width].b = 255 - img->data[x + y*img->width].b;
        }
}

// Interpolates between the 4 surrounding pixels

Rgba imageRgbaInterpolate(ImageRGBA *img, float x, float y)
{
    const int w = img->width;
    const int h = img->height;
    int ix, iy, iix, iiy;
    float fx, fy, dfx, dfy;
    
    if (x < 0)
        x = 0;
    if (y < 0)
        y = 0;
    if (y > (h-1))
        y = h-1;
    if (x > (w-1))
        x = w-1;

    ix = int(x);
    iy = int(y);
    
    iix = ix + 1;
    iiy = iy + 1;
    if (iix > (w-1))
        iix = 0;
    if (iiy > (h-1))
        iiy = 0;

    fx = x - ix;
    fy = y - iy;
    dfx = 1 - fx;
    dfy = 1 - fy;
        
    Rgba interpolated;
    Rgba top, bottom;
    Rgba topleft, topright, bottomleft, bottomright;

    topleft = img->data[ix + w*iy];
    topright = img->data[iix + w*iy];
    bottomleft = img->data[ix + w*iiy];
    bottomright = img->data[iix + w*iiy];

    top.r = int(dfx*topleft.r + fx*topright.r);
    top.g = int(dfx*topleft.g + fx*topright.g);
    top.b = int(dfx*topleft.b + fx*topright.b);
//    top.a = int(dfx*topleft.a + fx*topright.a);

    bottom.r = int(dfx*bottomleft.r + fx*bottomright.r);
    bottom.g = int(dfx*bottomleft.g + fx*bottomright.g);
    bottom.b = int(dfx*bottomleft.b + fx*bottomright.b);
//    bottom.a = int(dfx*bottomleft.a + fx*bottomright.a);

    interpolated.r = int(dfy*top.r + fy*bottom.r);
    interpolated.g = int(dfy*top.g + fy*bottom.g);
    interpolated.b = int(dfy*top.b + fy*bottom.b);
//    interpolated.a = int(dfy*top.a + fy*bottom.a);
    interpolated.a = 255;

    return interpolated;
}

int imageRgbaInterpolateSubImage(ImageRGBA *img, float x, float y, int w, int h, int offset)
{
    int ix, iy, iix, iiy;
    float fx, fy, dfx, dfy;
    
    ix = int(x);
    iy = int(y);
    
    if (ix < 0)
    {
        ix += w;
        x += w;
    }
    if (iy < 0)
    {
        iy += h;
        y += h;
    }
    if (ix > (w-1))
    {
        ix -= w;
        x -= w;
    }
    if (iy > (h-1))
    {
        iy -= h;
        y -= h;
    }


    fx = x - ix;
    fy = y - iy;
    dfx = 1 - fx;
    dfy = 1 - fy;
    
    iix = ix + 1;
    iiy = iy + 1;
    if (iix > (w-1))
        iix -= w;
    if (iiy > (h-1))
        iiy -= h;
        
        
    int interpolated;
    int top, bottom;
    int topleft, topright, bottomleft, bottomright;

    topleft = img->data[offset + ix + w*iy].r;
    topright = img->data[offset + iix + w*iy].r;
    bottomleft = img->data[offset + ix + w*iiy].r;
    bottomright = img->data[offset + iix + w*iiy].r;

    top = int(dfx*topleft + fx*topright);
    bottom = int(dfx*bottomleft + fx*bottomright);

    interpolated = int(dfy*top + fy*bottom);

    return interpolated;
}

Rgba imageRgbaInterpolateColors(float x, float y, Rgba topleft, Rgba topright, Rgba bottomleft, Rgba bottomright)
{
    int ix, iy;
    float fx, fy, dfx, dfy;
    
    ix = int(x);
    iy = int(y);
    fx = x - ix;
    fy = y - iy;
    dfx = 1 - fx;
    dfy = 1 - fy;
        
    Rgba interpolated;
    Rgba top, bottom;

    top.r = int(dfx*topleft.r + fx*topright.r);
    top.g = int(dfx*topleft.g + fx*topright.g);
    top.b = int(dfx*topleft.b + fx*topright.b);
//    top.a = int(dfx*topleft.a + fx*topright.a);

    bottom.r = int(dfx*bottomleft.r + fx*bottomright.r);
    bottom.g = int(dfx*bottomleft.g + fx*bottomright.g);
    bottom.b = int(dfx*bottomleft.b + fx*bottomright.b);
//    bottom.a = int(dfx*bottomleft.a + fx*bottomright.a);

    interpolated.r = int(dfy*top.r + fy*bottom.r);
    interpolated.g = int(dfy*top.g + fy*bottom.g);
    interpolated.b = int(dfy*top.b + fy*bottom.b);
//    interpolated.a = int(dfy*top.a + fy*bottom.a);
    interpolated.a = 255;

    return interpolated;
}


// Convertes from RGB mode to HSV mode
//   -> http://de.wikipedia.org/wiki/HSV-Farbraum

Hsva RGBtoHSV(Rgba RGBColor)
{
    // R, G, B: red, green, blue
    // H, S, V: hue, saturation, value
    // MAX = max(R, G, B)
    // MIN = min(R, G, B)
    
    float R, G, B, MAX, MIN;
    Hsva HSVColor;
    
    R = RGBColor.r / 255.0;
    G = RGBColor.g / 255.0;
    B = RGBColor.b / 255.0;
    
    MAX = R;
    if (G > MAX)
        MAX = G;
    if (B > MAX)
        MAX = B;
                  
    MIN = R;
    if (G < MIN)
        MIN = G;
    if (B < MIN)
        MIN = B;
        
    // let's transform RGB -> HSV:
    if (MAX != MIN)
    {
        if (MAX == R)
            HSVColor.h = (0.0 + (G - B) / (MAX - MIN)) * 60.0;
        if (MAX == G)
            HSVColor.h = (2.0 + (B - R) / (MAX - MIN)) * 60.0;
        if (MAX == B)
            HSVColor.h = (4.0 + (R - G) / (MAX - MIN)) * 60.0;
    }
            
    if (MAX > 0)                    
        HSVColor.s = (MAX - MIN) / MAX;
        
    HSVColor.v = MAX;
    
    HSVColor.a = RGBColor.a;
    return HSVColor;
}

Rgba HSVtoRGB(Hsva HSVColor)
{
    // http://de.wikipedia.org/wiki/HSV-Farbraum
    
    float Hi, f, p, q, t;
    Rgba RGBColor;
    
    // roger, now transform it back:
    Hi = int(fmod(HSVColor.h / 60.0, 6));
    f = (HSVColor.h / 60.0) - Hi;
    p = HSVColor.v * (1.0 - HSVColor.s);
    q = HSVColor.v * (1.0 - (HSVColor.s * f));
    t = HSVColor.v * (1.0 - (HSVColor.s * (1.0 - f)));
        
    if (Hi == 0)
    {
        RGBColor.r = int(HSVColor.v * 255);
        RGBColor.g = int(t * 255);
        RGBColor.b = int(p * 255);
    }
    else if (Hi == 1)
    {
        RGBColor.r = int(q * 255);
        RGBColor.g = int(HSVColor.v * 255);
        RGBColor.b = int(p * 255);
    }
    else if (Hi == 2)
    {
        RGBColor.r = int(p * 255);
        RGBColor.g = int(HSVColor.v * 255);
        RGBColor.b = int(t * 255);
    }
    else if (Hi == 3)
    {
        RGBColor.r = int(p * 255);
        RGBColor.g = int(q * 255);
        RGBColor.b = int(HSVColor.v * 255);
    }
    else if (Hi == 4)
    {
        RGBColor.r = int(t * 255);
        RGBColor.g = int(p * 255);
        RGBColor.b = int(HSVColor.v * 255);
    }
    else if (Hi == 5)
    {
        RGBColor.r = int(HSVColor.v * 255);
        RGBColor.g = int(p * 255);
        RGBColor.b = int(q * 255);
    }
    
    RGBColor.a = HSVColor.a;
    return RGBColor;
}

// Gaussian Blur
void gaussian(ImageRGBA *img, ImageRGBA *temp2, int lowAreaX, int lowAreaY, int highAreaX, int highAreaY, float value1, int mode, unsigned char calc)
{
    int loops = 1;
    float oldValue1 = value1;
    ImageRGBA *swap;

    if (mode == 2)
        loops = int(oldValue1);
    for (int l = 0; l < loops; l++)
    {
        if (l > 0)
            value1 = int(exp((l*-l)/oldValue1) * oldValue1);
        
        if (value1 > 0)
        {
            horizontal_blur(img, temp2, lowAreaX, lowAreaY, highAreaX, highAreaY, value1, mode, calc);

            swap = img;
            img = temp2;
            temp2 = swap;
    
            vertical_blur(img, temp2, lowAreaX, lowAreaY, highAreaX, highAreaY, value1, mode, calc);
        }
        swap = img;
        img = temp2;
        temp2 = swap;
    }
}

void horizontal_blur(ImageRGBA *img, ImageRGBA *temp2, int lowAreaX, int lowAreaY, int highAreaX, int highAreaY, float value1, int mode, unsigned char calc)
{
    int mx, location, count = 0;
    int R = 0, G = 0, B = 0, A = 0;

    for (int _y = lowAreaY; _y <= highAreaY; _y++)
    {
        for (int _x = lowAreaX; _x <= highAreaX; _x++)
        {
            if (_x == lowAreaX)
            {
                R = 0;
                G = 0;
                B = 0;
                A = 0;
                count = 0;
                for (int x = 0; x <= int(value1); x++)
                {
                    mx = _x + x;
                    
                    if (mx < lowAreaX) { mx = lowAreaX; }
                    if (mx > highAreaX)
                        break;
                    
                    if (_y > highAreaY)
                        break;
                    if (!(_y < lowAreaY))
                    {
    
                        count++;
                        location = mx + img->width * _y;
                        
                        R += temp2->data[location].r;
                        G += temp2->data[location].g;
                        B += temp2->data[location].b;
                        A += temp2->data[location].a;
                    }
                }
            }
            else
            {
                if ((_x - int(value1)) > lowAreaX)
                {
                    if (_y > highAreaY)
                        break;
                    if (!(_y < lowAreaY))
                    {
                        count--;
                        location = (_x - int(value1) - 1) + img->width * _y;
                        
                        R -= temp2->data[location].r;
                        G -= temp2->data[location].g;
                        B -= temp2->data[location].b;
                        A -= temp2->data[location].a;
                    }
                }
                if ((_x + int(value1)) <= highAreaX)
                {
                    if (_y > highAreaY)
                        break;
                    if (!(_y < lowAreaY))
                    {
                        count++;
                        location = (_x + int(value1)) + img->width * _y;
                        
                        R += temp2->data[location].r;
                        G += temp2->data[location].g;
                        B += temp2->data[location].b;
                        A += temp2->data[location].a;
                    }
                }
            }
            if (count != 0)
            {
                int location = _x + img->width * _y;
                int _R = (R / count);
                int _G = (G / count);
                int _B = (B / count);
                int _A = (A / count);
                if (calc == 2)
                {
                    _R = int(((float)_A / 255 * _R) + ((float)img->data[location].a / 255 * img->data[location].r));
                    _G = int(((float)_A / 255 * _G) + ((float)img->data[location].a / 255 * img->data[location].g));
                    _B = int(((float)_A / 255 * _B) + ((float)img->data[location].a / 255 * img->data[location].b));
                    _A = _A + img->data[location].a;
                    _R = int((float)_R / ((float)_A / 255));
                    _G = int((float)_G / ((float)_A / 255));
                    _B = int((float)_B / ((float)_A / 255));
                    _A = int((float)_A);
                }                

                if (_R < 0) { _R = 0; }
                if (_G < 0) { _G = 0; }
                if (_B < 0) { _B = 0; }
                if (_A < 0) { _A = 0; }
                if (_R > 255) { _R = 255; }
                if (_G > 255) { _G = 255; }
                if (_B > 255) { _B = 255; }
                if (_A > 255) { _A = 255; }
                img->data[location] = (Rgba){_R, _G, _B, _A};
            }
        }
    }
}

void vertical_blur(ImageRGBA *img, ImageRGBA *temp2, int lowAreaX, int lowAreaY, int highAreaX, int highAreaY, float value1, int mode, unsigned char calc)
{
    int my, location, count = 0;
    int R = 0, G = 0, B = 0, A = 0;

    for (int _x = lowAreaX; _x <= highAreaX; _x++)
    {
        for (int _y = lowAreaY; _y <= highAreaY; _y++)
        {
            if (_y == lowAreaY)
            {
                R = 0;
                G = 0;
                B = 0;
                A = 0;
                count = 0;
                for (int y = 0; y <= int(value1); y++)
                {
                    my = _y + y;
                    
                    if (my < lowAreaY) { my = lowAreaY; }
                    if (my > highAreaY)
                        break;
                    
                    if (_x > highAreaX)
                        break;
                    if (!(_x < lowAreaX))
                    {
    
                        count++;
                        location = _x + img->width * my;
                        
                        R += temp2->data[location].r;
                        G += temp2->data[location].g;
                        B += temp2->data[location].b;
                        A += temp2->data[location].a;
                    }
                }
            }
            else
            {
                if ((_y - int(value1)) > lowAreaY)
                {
                    if (_x > highAreaX)
                        break;
                    if (!(_x < lowAreaX))
                    {
                        count--;
                        location = _x + img->width * (_y - int(value1) - 1);
                        
                        R -= temp2->data[location].r;
                        G -= temp2->data[location].g;
                        B -= temp2->data[location].b;
                        A -= temp2->data[location].a;
                    }
                }
                if ((_y + int(value1)) <= highAreaY)
                {
                    if (_x > highAreaX)
                        break;
                    if (!(_x < lowAreaX))
                    {
                        count++;
                        location = _x + img->width * (_y + int(value1));
                        
                        R += temp2->data[location].r;
                        G += temp2->data[location].g;
                        B += temp2->data[location].b;
                        A += temp2->data[location].a;
                    }
                }
            }
            if (count != 0)
            {
                int location = _x + img->width * _y;
                int _R = (R / count);
                int _G = (G / count);
                int _B = (B / count);
                int _A = (A / count);
                if (calc == 2)
                {
                    _R = int(((float)_A / 255 * _R) + ((float)img->data[location].a / 255 * img->data[location].r));
                    _G = int(((float)_A / 255 * _G) + ((float)img->data[location].a / 255 * img->data[location].g));
                    _B = int(((float)_A / 255 * _B) + ((float)img->data[location].a / 255 * img->data[location].b));
                    _A = _A + img->data[location].a;
                    _R = int((float)_R / ((float)_A / 255));
                    _G = int((float)_G / ((float)_A / 255));
                    _B = int((float)_B / ((float)_A / 255));
                    _A = int((float)_A);
                }
                
                if (_R < 0) { _R = 0; }
                if (_G < 0) { _G = 0; }
                if (_B < 0) { _B = 0; }
                if (_A < 0) { _A = 0; }
                if (_R > 255) { _R = 255; }
                if (_G > 255) { _G = 255; }
                if (_B > 255) { _B = 255; }
                if (_A > 255) { _A = 255; }
                img->data[location] = (Rgba){_R, _G, _B, _A};
            }
        }
    }
}

void motion_blur(ImageRGBA *img, ImageRGBA *temp2, int lowAreaX, int lowAreaY, int highAreaX, int highAreaY, float value1, float value2, int mode, unsigned char calc)
{
    int maxdist, maxdistX, maxdistY;
    int newX, newY, maxY, location;
    int oldX, oldY;
    int R = 0, G = 0, B = 0, A = 0, count = 0;
    float angle = value2 * M_PI / 180 - M_PI / 2;
//    imageRgbaSetArea(img, lowAreaX, lowAreaY, highAreaX+1, highAreaY+1, (Rgba){0, 0, 0, 0});

    for (int x = lowAreaX - 1; x <= highAreaX + 1; x++)
    {
        if (x == lowAreaX - 1 && angle < 0)
            maxY = highAreaY + 1;
        else if (x == highAreaX + 1 && angle > 0)
            maxY = highAreaY + 1;
        else
            maxY = lowAreaY - 1;
            
        for (int y = lowAreaY - 1; y <= maxY; y++)
        {
            R = 0;
            G = 0;
            B = 0;
            A = 0;
            count = 0;
            if (angle < 0)
                maxdistX = (highAreaX - x + 10);
            else if (angle > 0)
                maxdistX = x + 10;
            else
                maxdistX = highAreaX + 10;
            if (maxdistX > (highAreaX + 10))
                maxdistX = highAreaX + 10;
            else if (maxdist < (-(highAreaX + 10)))
                maxdist = -(highAreaX + 10);
            maxdistY = int(maxdistX / tan(angle)+10);
            if (maxdistY > (highAreaY + 10))
                maxdistY = highAreaY + 10;
            else if (maxdistY < (-(highAreaY + 10)))
                maxdistY = -(highAreaY + 10);
            maxdist = int(sqrt(maxdistX*maxdistX + maxdistY*maxdistY)+1);
            for (int dist = int(-value1); dist < maxdist; dist++)
            {
                // remove
                if ((dist - value1) >= 0)
                {
                    newX = int(x - sin(angle)*(dist-value1));
                    newY = int(y + cos(angle)*(dist-value1));
                    if (newX >= lowAreaX && newX <= highAreaX && newY >= lowAreaY && newY <= highAreaY)
                    {
                        location = newX + img->width * newY;
                        R -= temp2->data[location].r;
                        G -= temp2->data[location].g;
                        B -= temp2->data[location].b;
                        A -= temp2->data[location].a;
                        count--;
                    }
                }
                // add
                newX = int(x - sin(angle)*(dist+value1));
                newY = int(y + cos(angle)*(dist+value1));
                if (newX >= lowAreaX && newX <= highAreaX && newY >= lowAreaY && newY <= highAreaY)
                {
                    location = newX + img->width * newY;
                    R += temp2->data[location].r;
                    G += temp2->data[location].g;
                    B += temp2->data[location].b;
                    A += temp2->data[location].a;
                    count++;
                }
                // draw
                if (dist >= 0)
                {
                    newX = int(x - sin(angle)*dist);
                    newY = int(y + cos(angle)*dist);
                    if (oldX != newX || oldY != newY)
                    {
                        if (newX >= lowAreaX && newX <= highAreaX && newY >= lowAreaY && newY <= highAreaY)
                        {
                            location = newX + img->width * newY;
                            if (count != 0)
                            {
                                int _R = (R / count);
                                int _G = (G / count);
                                int _B = (B / count);
                                int _A = (A / count);
                                if (calc == 2)
                                {
                                    _R = int(((float)_A / 255 * _R) + ((float)img->data[location].a / 255 * img->data[location].r));
                                    _G = int(((float)_A / 255 * _G) + ((float)img->data[location].a / 255 * img->data[location].g));
                                    _B = int(((float)_A / 255 * _B) + ((float)img->data[location].a / 255 * img->data[location].b));
                                    _A = _A + img->data[location].a;
                                    _R = int((float)_R * ((float)255 / _A));
                                    _G = int((float)_G * ((float)255 / _A));
                                    _B = int((float)_B * ((float)255 / _A));
                                    _A = int((float)_A);
                                }
                                
                                if (_R < 0) { _R = 0; }
                                if (_G < 0) { _G = 0; }
                                if (_B < 0) { _B = 0; }
                                if (_A < 0) { _A = 0; }
                                if (_R > 255) { _R = 255; }
                                if (_G > 255) { _G = 255; }
                                if (_B > 255) { _B = 255; }
                                if (_A > 255) { _A = 255; }
                                img->data[location] = (Rgba){_R, _G, _B, _A};
                            }
                        }
                    }
                    oldX = newX;
                    oldY = newY;
                }
            }
        }
    }
}

void holdHighest(int *stack, int numElements, int newElement)
{
    int hold;
    for (int i = 0; i < numElements; i++)
    {
        if (newElement > stack[i])
        {
            hold = stack[i];
            stack[i] = newElement;
            holdHighest(stack, numElements, hold);
            break;
        }
    }
}

---