aaLine.cpp

Go to the documentation of this file.

// aaLine.cpp

/*************************************************************/
//
// aaLine
//
// Draw antialiased lines
//
//-------------------------------------------------------------
//
// v 1.3 - 2007/08/16 - Colour interpolated AA stroked lines
// v 1.2 - 2007/01/15 - Coloured AA stroked lines on unsigned char data instead
// v 1.1 - 2007/01/06 - Coloured AA stroked lines
// v 1.0 - 2006/04/19 - Initial release
//
// See LICENSE.txt for distribution and usage restrictions
// Copyright (c) 2005-2007 Simon Chorley
// www.mylaboratory.co.uk - greylab@mylaboratory.co.uk
//
/*************************************************************/

///Draws antialiased lines (Implementation)
/**
 * Draws antialiased lines of various styles.
 * @file aaLine.cpp
 * @version 1.3 - 2007/08/16
 */


#include "aaLine.h"

#include <iostream>


///Return interger part
int ipart(double x)     //integer part
{
        return((int)x);
}


///Return fractional part
double fpart(double x)  //floating point part
{
        return(x-ipart(x));
}


///Return 1.0-fractional part
double rfpart(double x) //1-floating point part
{
        return(1.0-fpart(x));
}

/*#define PLOTX(x, y, c1, c2) data[0+3*(x+y*stride)] = (unsigned char)(255*(1.0-c1)); \
        data[1+3*(x+y*stride)] = (unsigned char)(255*(1.0-c1)); \
        data[2+3*(x+y*stride)] = (unsigned char)(255*(1.0-c1)); \
        data[0+3*(x+(y+1)*stride)] = (unsigned char)(255*(1.0-c2)); \
        data[1+3*(x+(y+1)*stride)] = (unsigned char)(255*(1.0-c2)); \
        data[2+3*(x+(y+1)*stride)] = (unsigned char)(255*(1.0-c2));// \
//      cerr << ">x" << x << ",y" << y << ",c1" << c1 << ",c2" << c2 << '\n';

#define PLOTY(x, y, c1, c2) data[0+3*(x+y*stride)] = (unsigned char)(255*(1.0-c1)); \
        data[1+3*(x+y*stride)] = (unsigned char)(255*(1.0-c1)); \
        data[2+3*(x+y*stride)] = (unsigned char)(255*(1.0-c1)); \
        data[0+3*(x+1+y*stride)] = (unsigned char)(255*(1.0-c2)); \
        data[1+3*(x+1+y*stride)] = (unsigned char)(255*(1.0-c2)); \
        data[2+3*(x+1+y*stride)] = (unsigned char)(255*(1.0-c2));// \
//      cerr << ">x" << x << ",y" << y << ",c1" << c1 << ",c2" << c2 << '\n';*/


///Return smaller of two values
void sub(unsigned char &ch, unsigned char val)
{
        if (val < ch)
                ch = val;
}

///Draw AA line fragment (x-direction)
#define PLOTX(x, y, c1, c2) sub(data[0+3*(x+y*stride)], (unsigned char)(255*(1.0-c1))); \
        sub(data[1+3*(x+y*stride)], (unsigned char)(255*(1.0-c1))); \
        sub(data[2+3*(x+y*stride)], (unsigned char)(255*(1.0-c1))); \
        sub(data[0+3*(x+(y+1)*stride)], (unsigned char)(255*(1.0-c2))); \
        sub(data[1+3*(x+(y+1)*stride)], (unsigned char)(255*(1.0-c2))); \
        sub(data[2+3*(x+(y+1)*stride)], (unsigned char)(255*(1.0-c2)));// \
//      cerr << ">x" << x << ",y" << y << ",c1" << c1 << ",c2" << c2 << '\n';

///Draw AA line fragment (y-direction)
#define PLOTY(x, y, c1, c2) sub(data[0+3*(x+y*stride)], (unsigned char)(255*(1.0-c1))); \
        sub(data[1+3*(x+y*stride)], (unsigned char)(255*(1.0-c1))); \
        sub(data[2+3*(x+y*stride)], (unsigned char)(255*(1.0-c1))); \
        sub(data[0+3*(x+1+y*stride)], (unsigned char)(255*(1.0-c2))); \
        sub(data[1+3*(x+1+y*stride)], (unsigned char)(255*(1.0-c2))); \
        sub(data[2+3*(x+1+y*stride)], (unsigned char)(255*(1.0-c2)));// \
//      cerr << ">x" << x << ",y" << y << ",c1" << c1 << ",c2" << c2 << '\n';


/*void PLOTX(unsigned char *data, int stride, int x, int y, double c1, double c2)
{
        data[0+3*(x+y*stride)] = (data[0+3*(x+y*stride)]+(255.0*(1.0-c1)))/2;
        data[1+3*(x+y*stride)] = (data[1+3*(x+y*stride)]+(255.0*(1.0-c1)))/2;
        data[2+3*(x+y*stride)] = (data[2+3*(x+y*stride)]+(255.0*(1.0-c1)))/2;
        data[0+3*(x+(y+1)*stride)] = (data[0+3*(x+(y+1)*stride)]+(255.0*(1.0-c2)))/2;
        data[1+3*(x+(y+1)*stride)] = (data[1+3*(x+(y+1)*stride)]+(255.0*(1.0-c2)))/2;
        data[2+3*(x+(y+1)*stride)] = (data[2+3*(x+(y+1)*stride)]+(255.0*(1.0-c2)))/2;
//      cerr << ">x" << x << ",y" << y << ",c1" << c1 << ",c2" << c2 << '\n';
}

void PLOTY(unsigned char *data, int stride, int x, int y, double c1, double c2)
{
        data[0+3*(x+y*stride)] = (data[0+3*(x+y*stride)]+(255.0*(1.0-c1)))/2;
        data[1+3*(x+y*stride)] = (data[1+3*(x+y*stride)]+(255.0*(1.0-c1)))/2;
        data[2+3*(x+y*stride)] = (data[2+3*(x+y*stride)]+(255.0*(1.0-c1)))/2;
        data[0+3*(x+1+y*stride)] = (data[0+3*(x+1+y*stride)]+(255.0*(1.0-c2)))/2;
        data[1+3*(x+1+y*stride)] = (data[1+3*(x+1+y*stride)]+(255.0*(1.0-c2)))/2;
        data[2+3*(x+1+y*stride)] = (data[2+3*(x+1+y*stride)]+(255.0*(1.0-c2)))/2;
//      cerr << ">x" << x << ",y" << y << ",c1" << c1 << ",c2" << c2 << '\n';
}*/


///Draws greyscale antialiased line
/**
 * Draw greyscale antialiased line between coordinate points.
 * @param data Data to draw line to.
 * @param stride Width of data array.
 * @param x1 Starting x pixel.
 * @param x2 Ending x pixel.
 * @param y1 Starting y pixel.
 * @param y2 Ending y pixel.
 */
void aaline(unsigned char *data, int stride, int x1, int x2, float y1, float y2)
{
        double dx = x2-x1;
        double dy = y2-y1;
        double gradient = dy/dx;
        double xend, yend, interx, intery;
        int xpxl1, ypxl1, xpxl2, ypxl2, x, y;
        if ((gradient < 1.0) && (gradient > -1.0))
        {
                // x coordinates are always integers
                xpxl1 = x1;
                intery = y1+gradient;
                xpxl2 = x2;
                for (x = xpxl1; x <= xpxl2; ++x)
                {
                        PLOTX(x, ipart(intery), rfpart(intery), fpart(intery));
                        intery = intery + gradient;
                }
        }
        else
        {
                dx = x2-x1;
                dy = y2-y1;
                gradient = dx/dy;
                yend = ipart(y1+0.5);
                ypxl1 = (int)yend;
                yend = ipart(y2+0.5);
                xend = x2+gradient*(yend-y2);
                ypxl2 = (int)yend;
                if (gradient > 0.0)
                {
                        interx = x1;
                        for (y = ypxl1; y <= ypxl2; ++y)
                        {
                            PLOTY(ipart(interx), y, rfpart(interx), fpart(interx));
                                interx = interx+gradient;
                        }
                }
                else
                {
                        interx = xend;
                        for (y = ypxl2; y <= ypxl1; ++y)
                        {
                            PLOTY(ipart(interx), y, rfpart(interx), fpart(interx));
                                interx = interx+gradient;
                        }
                }
        }
}


///Draw coloured AA line fragment (x-direction)
#define PLOTCX(x, y, c1, c2) data[0+3*(x+y*stride)] = (unsigned char)((1.0-c1)*data[0+3*(x+y*stride)]+r*c1); \
        data[1+3*(x+y*stride)] = (unsigned char)((1.0-c1)*data[1+3*(x+y*stride)]+g*c1); \
        data[2+3*(x+y*stride)] = (unsigned char)((1.0-c1)*data[2+3*(x+y*stride)]+b*c1); \
        data[0+3*(x+(y+1)*stride)] = (unsigned char)((1.0-c2)*data[0+3*(x+(y+1)*stride)]+r*c2); \
        data[1+3*(x+(y+1)*stride)] = (unsigned char)((1.0-c2)*data[1+3*(x+(y+1)*stride)]+g*c2); \
        data[2+3*(x+(y+1)*stride)] = (unsigned char)((1.0-c2)*data[2+3*(x+(y+1)*stride)]+b*c2);
//      cerr << ">x" << x << ",y" << y << ",c1" << c1 << ",c2" << c2 << '\n';

///Draw coloured AA line fragment (y-direction)
#define PLOTCY(x, y, c1, c2) data[0+3*(x+y*stride)] = (unsigned char)((1.0-c1)*data[0+3*(x+y*stride)]+r*c1); \
        data[1+3*(x+y*stride)] = (unsigned char)((1.0-c1)*data[1+3*(x+y*stride)]+g*c1); \
        data[2+3*(x+y*stride)] = (unsigned char)((1.0-c1)*data[2+3*(x+y*stride)]+b*c1); \
        data[0+3*(x+1+y*stride)] = (unsigned char)((1.0-c2)*data[0+3*(x+1+y*stride)]+r*c2); \
        data[1+3*(x+1+y*stride)] = (unsigned char)((1.0-c2)*data[1+3*(x+1+y*stride)]+g*c2); \
        data[2+3*(x+1+y*stride)] = (unsigned char)((1.0-c2)*data[2+3*(x+1+y*stride)]+b*c2);
//      cerr << ">x" << x << ",y" << y << ",c1" << c1 << ",c2" << c2 << '\n';

///Draws colour antialiased line
/**
 * Draw colour antialiased line between coordinate points.
 * @param data Data to draw line to.
 * @param stride Width of data array.
 * @param x1 Starting x pixel.
 * @param x2 Ending x pixel.
 * @param y1 Starting y pixel.
 * @param y2 Ending y pixel.
 * @param r Red intensity.
 * @param g Green intensity.
 * @param b Blue intensity.
 */
void aacolline(unsigned char *data, int stride, int x1, int x2, float y1, float y2, unsigned char r, unsigned char g, unsigned char b)
{
        double dx = x2-x1;
        double dy = y2-y1;
        double gradient = dy/dx;
        double xend, yend, interx, intery;
        int xpxl1, ypxl1, xpxl2, ypxl2, x, y;
        if ((gradient < 1.0) && (gradient > -1.0))
        {
                // x coordinates are always integers
                xpxl1 = x1;
                intery = y1+gradient;
                xpxl2 = x2;
                for (x = xpxl1; x <= xpxl2; ++x)
                {
                        PLOTCX(x, ipart(intery), rfpart(intery), fpart(intery));
                        intery = intery + gradient;
                }
        }
        else
        {
                dx = x2-x1;
                dy = y2-y1;
                gradient = dx/dy;
                yend = ipart(y1+0.5);
                ypxl1 = (int)yend;
                yend = ipart(y2+0.5);
                xend = x2+gradient*(yend-y2);
                ypxl2 = (int)yend;
                if (gradient > 0.0)
                {
                        interx = x1;
                        for (y = ypxl1; y <= ypxl2; ++y)
                        {
                            PLOTCY(ipart(interx), y, rfpart(interx), fpart(interx));
                                interx = interx+gradient;
                        }
                }
                else
                {
                        interx = xend;
                        for (y = ypxl2; y <= ypxl1; ++y)
                        {
                            PLOTCY(ipart(interx), y, rfpart(interx), fpart(interx));
                                interx = interx+gradient;
                        }
                }
        }
}


///Draw coloured stroked AA line fragment (x-direction)
#define PLOTCSY(x, y, c1, c2) if ((x-stroke/2 >= 0) && (x-stroke/2 < w) && (y >= 0) && (y < h)) { \
                data[0+3*(x-stroke/2+y*stride)] = FXREDVAL(c)*a*c1+(1.0-a*c1)*data[0+3*(x-stroke/2+y*stride)]; \
                data[1+3*(x-stroke/2+y*stride)] = FXGREENVAL(c)*a*c1+(1.0-a*c1)*data[1+3*(x-stroke/2+y*stride)]; \
                data[2+3*(x-stroke/2+y*stride)] = FXBLUEVAL(c)*a*c1+(1.0-a*c1)*data[2+3*(x-stroke/2+y*stride)]; } \
        for (i = 1; i < stroke; ++i) \
                if ((i+x-stroke/2 >= 0) && (i+x-stroke/2 < w) && (y >= 0) && (y < h)) { \
                        data[0+3*(i+x-stroke/2+y*stride)] = FXREDVAL(c)*a+(1.0-a)*data[0+3*(i+x-stroke/2+y*stride)]; \
                        data[1+3*(i+x-stroke/2+y*stride)] = FXGREENVAL(c)*a+(1.0-a)*data[1+3*(i+x-stroke/2+y*stride)]; \
                        data[2+3*(i+x-stroke/2+y*stride)] = FXBLUEVAL(c)*a+(1.0-a)*data[2+3*(i+x-stroke/2+y*stride)]; } \
        if ((x+(int)(0.5+(float)stroke/2.0) >= 0) && (x+(int)(0.5+(float)stroke/2.0) < w) && (y >= 0) && (y < h)) { \
                data[0+3*(x+(int)(0.5+(float)stroke/2.0)+y*stride)] = FXREDVAL(c)*a*c2+(1.0-a*c2)*data[0+3*(x+(int)(0.5+(float)stroke/2.0)+y*stride)]; \
                data[1+3*(x+(int)(0.5+(float)stroke/2.0)+y*stride)] = FXGREENVAL(c)*a*c2+(1.0-a*c2)*data[1+3*(x+(int)(0.5+(float)stroke/2.0)+y*stride)]; \
                data[2+3*(x+(int)(0.5+(float)stroke/2.0)+y*stride)] = FXBLUEVAL(c)*a*c2+(1.0-a*c2)*data[2+3*(x+(int)(0.5+(float)stroke/2.0)+y*stride)]; }

///Draw coloured stroked AA line fragment (y-direction)
#define PLOTCSX(x, y, c1, c2) if ((x >= 0) && (x < w) && (y-stroke/2 >= 0) && (y-stroke/2 < h)) { \
                data[0+3*(x+(y-stroke/2)*stride)] = FXREDVAL(c)*a*c1+(1.0-a*c1)*data[0+3*(x+(y-stroke/2)*stride)]; \
                data[1+3*(x+(y-stroke/2)*stride)] = FXGREENVAL(c)*a*c1+(1.0-a*c1)*data[1+3*(x+(y-stroke/2)*stride)]; \
                data[2+3*(x+(y-stroke/2)*stride)] = FXBLUEVAL(c)*a*c1+(1.0-a*c1)*data[2+3*(x+(y-stroke/2)*stride)]; } \
        for (i = 1; i < stroke; ++i) \
                if ((x >= 0) && (x < w) && (y+i-stroke/2 >= 0) && (y+i-stroke/2 < h)) { \
                        data[0+3*(x+(y+i-stroke/2)*stride)] = FXREDVAL(c)*a+(1.0-a)*data[0+3*(x+(y+i-stroke/2)*stride)]; \
                        data[1+3*(x+(y+i-stroke/2)*stride)] = FXGREENVAL(c)*a+(1.0-a)*data[1+3*(x+(y+i-stroke/2)*stride)]; \
                        data[2+3*(x+(y+i-stroke/2)*stride)] = FXBLUEVAL(c)*a+(1.0-a)*data[2+3*(x+(y+i-stroke/2)*stride)]; } \
        if ((x >= 0) && (x < w) && (y+(int)(0.5+(float)stroke/2.0) >= 0) && (y+(int)(0.5+(float)stroke/2.0) < h)) { \
                data[0+3*(x+(y+(int)(0.5+(float)stroke/2.0))*stride)] = FXREDVAL(c)*a*c2+(1.0-a*c2)*data[0+3*(x+(y+(int)(0.5+(float)stroke/2.0))*stride)]; \
                data[1+3*(x+(y+(int)(0.5+(float)stroke/2.0))*stride)] = FXGREENVAL(c)*a*c2+(1.0-a*c2)*data[1+3*(x+(y+(int)(0.5+(float)stroke/2.0))*stride)]; \
                data[2+3*(x+(y+(int)(0.5+(float)stroke/2.0))*stride)] = FXBLUEVAL(c)*a*c2+(1.0-a*c2)*data[2+3*(x+(y+(int)(0.5+(float)stroke/2.0))*stride)]; }

///Draws colour stroked antialiased line
/**
 * Draw colour antialiased line with set thickness between coordinate points.
 * @param data Data to draw line to.
 * @param stride Width of data array.
 * @param x1 Starting x pixel.
 * @param x2 Ending x pixel.
 * @param y1 Starting y pixel.
 * @param y2 Ending y pixel.
 * @param c Colour.
 * @param stroke Line width.
 * @param w Width of drawing area (for clipping).
 * @param h Height of drawing area (for clipping).
 */
void aacolstrokeline(unsigned char *data, int stride, int x1, int x2, float y1, float y2, FXColor c, int stroke, int w, int h)
{
        int i;
        float a = FXALPHAVAL(c)/255.0;
        double dx = x2-x1;
        double dy = y2-y1;
        double gradient = dy/dx;
        double xend, yend, interx, intery;
        int xpxl1, ypxl1, xpxl2, ypxl2, x, y;
        if ((gradient < 1.0) && (gradient > -1.0))
        {
                // x coordinates are always integers
                xpxl1 = x1;
                intery = y1+gradient;
                xpxl2 = x2;
                for (x = xpxl1; x <= xpxl2; ++x)
                {
                        PLOTCSX(x, ipart(intery), rfpart(intery), fpart(intery));
                        intery = intery + gradient;
                }
        }
        else
        {
                dx = x2-x1;
                dy = y2-y1;
                gradient = dx/dy;
                yend = ipart(y1+0.5);
                ypxl1 = (int)yend;
                yend = ipart(y2+0.5);
                xend = x2+gradient*(yend-y2);
                ypxl2 = (int)yend;
                if (gradient > 0.0)
                {
                        interx = x1;
                        for (y = ypxl1; y <= ypxl2; ++y)
                        {
                            PLOTCSY(ipart(interx), y, rfpart(interx), fpart(interx));
                                interx = interx+gradient;
                        }
                }
                else
                {
                        interx = xend;
                        for (y = ypxl2; y <= ypxl1; ++y)
                        {
                            PLOTCSY(ipart(interx), y, rfpart(interx), fpart(interx));
                                interx = interx+gradient;
                        }
                }
        }
}


///Draws gradient coloured stroked antialiased line
/**
 * Draw antialiased line with set thickness between coordinate points, interpolating the colour between the ends.
 * @param data Data to draw line to.
 * @param stride Width of data array.
 * @param x1 Starting x pixel.
 * @param x2 Ending x pixel.
 * @param y1 Starting y pixel.
 * @param y2 Ending y pixel.
 * @param sc Start colour.
 * @param ec End colour.
 * @param stroke Line width.
 * @param w Width of drawing area (for clipping).
 * @param h Height of drawing area (for clipping).
 */
void aarampcolstrokeline(unsigned char *data, int stride, int x1, int x2, float y1, float y2, FXColor sc, FXColor ec, int stroke, int w, int h)
{
        int i;
        float a = FXALPHAVAL(sc)/255.0;
        double dx = x2-x1;
        double dy = y2-y1;
        double gradient = dy/dx;
        double xend, yend, interx, intery;
        int xpxl1, ypxl1, xpxl2, ypxl2, x, y;
        float interp;
        FXColor c;
        if ((gradient < 1.0) && (gradient > -1.0))
        {
                // x coordinates are always integers
                xpxl1 = x1;
                intery = y1+gradient;
                xpxl2 = x2;
                for (x = xpxl1; x <= xpxl2; ++x)
                {
                        interp = (float)(x-xpxl1)/(float)(xpxl2-xpxl1);
                        c = FXRGB((float)FXREDVAL(sc)*(1.0-interp)+(float)FXREDVAL(ec)*interp, (float)FXGREENVAL(sc)*(1.0-interp)+(float)FXGREENVAL(ec)*interp, (float)FXBLUEVAL(sc)*(1.0-interp)+(float)FXBLUEVAL(ec)*interp);
                        PLOTCSX(x, ipart(intery), rfpart(intery), fpart(intery));
                        intery = intery + gradient;
                }
        }
        else
        {
                dx = x2-x1;
                dy = y2-y1;
                gradient = dx/dy;
                yend = ipart(y1+0.5);
                ypxl1 = (int)yend;
                yend = ipart(y2+0.5);
                xend = x2+gradient*(yend-y2);
                ypxl2 = (int)yend;
                if (gradient > 0.0)
                {
                        interx = x1;
                        for (y = ypxl1; y <= ypxl2; ++y)
                        {
                                interp = (float)(y-ypxl1)/(float)(ypxl2-ypxl1);
                                c = FXRGB((float)FXREDVAL(sc)*(1.0-interp)+(float)FXREDVAL(ec)*interp, (float)FXGREENVAL(sc)*(1.0-interp)+(float)FXGREENVAL(ec)*interp, (float)FXBLUEVAL(sc)*(1.0-interp)+(float)FXBLUEVAL(ec)*interp);
                            PLOTCSY(ipart(interx), y, rfpart(interx), fpart(interx));
                                interx = interx+gradient;
                        }
                }
                else
                {
                        interx = xend;
                        for (y = ypxl2; y <= ypxl1; ++y)
                        {
                                interp = (float)(y-ypxl2)/(float)(ypxl1-ypxl2);
                                c = FXRGB((float)FXREDVAL(sc)*(1.0-interp)+(float)FXREDVAL(ec)*interp, (float)FXGREENVAL(sc)*(1.0-interp)+(float)FXGREENVAL(ec)*interp, (float)FXBLUEVAL(sc)*(1.0-interp)+(float)FXBLUEVAL(ec)*interp);
                            PLOTCSY(ipart(interx), y, rfpart(interx), fpart(interx));
                                interx = interx+gradient;
                        }
                }
        }
}

---