wrlib/draw.c

   1 /* draw.c - pixel plotting, line drawing
   2  *
   3  * Raster graphics library
   4  *
   5  * Copyright (c) 1998-2003 Dan Pascu
   6  * Copyright (c) 2000-2003 Alfredo K. Kojima
   7  *
   8  *  This library is free software; you can redistribute it and/or
   9  *  modify it under the terms of the GNU Library General Public
  10  *  License as published by the Free Software Foundation; either
  11  *  version 2 of the License, or (at your option) any later version.
  12  *
  13  *  This library is distributed in the hope that it will be useful,
  14  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  *  Library General Public License for more details.
  17  *
  18  *  You should have received a copy of the GNU Library General Public
  19  *  License along with this library; if not, write to the Free
  20  *  Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston,
  21  *  MA 02110-1301, USA.
  22  */
  23
  24 #include <config.h>
  25
  26 #include <stdio.h>
  27 #include <stdlib.h>
  28 #include <assert.h>
  29
  30 #include "wraster.h"
  31
  32 #define MIN(a,b)        ((a) < (b) ? (a) : (b))
  33 #define MAX(a,b)        ((a) > (b) ? (a) : (b))
  34
  35 /*
  36  * Returns the color of the pixel at coordinates (x, y) in "color".
  37  */
  38 Bool RGetPixel(RImage * image, int x, int y, RColor * color)
  39 {
  40         int ofs;
  41
  42         assert(image != NULL);
  43         if (x < 0 || x >= image->width || y < 0 || y >= image->height)
  44                 return False;
  45
  46         if (image->format == RRGBAFormat) {
  47                 ofs = (y * image->width + x) * 4;
  48                 color->red = image->data[ofs++];
  49                 color->green = image->data[ofs++];
  50                 color->blue = image->data[ofs++];
  51                 color->alpha = image->data[ofs];
  52         } else {
  53                 ofs = (y * image->width + x) * 3;
  54                 color->red = image->data[ofs++];
  55                 color->green = image->data[ofs++];
  56                 color->blue = image->data[ofs];
  57                 /* If the image does not have alpha channel, we consider alpha 255 */
  58                 color->alpha = 255;
  59         }
  60
  61         return True;
  62 }
  63
  64 void RPutPixel(RImage *image, int x, int y, const RColor *color)
  65 {
  66         unsigned char *ptr;
  67
  68         assert(image != NULL);
  69         assert(color != NULL);
  70         if (x < 0 || x >= image->width || y < 0 || y >= image->height)
  71                 return;
  72
  73         if (image->format == RRGBAFormat) {
  74                 ptr = image->data + (y * image->width + x) * 4;
  75         } else {
  76                 ptr = image->data + (y * image->width + x) * 3;
  77         }
  78
  79         if (color->alpha == 255) {
  80                 *ptr++ = color->red;
  81                 *ptr++ = color->green;
  82                 *ptr++ = color->blue;
  83                 if (image->format == RRGBAFormat) {
  84                         *ptr = 255;
  85                 }
  86         } else {
  87                 register int alpha, nalpha, r, g, b;
  88
  89                 r = color->red;
  90                 g = color->green;
  91                 b = color->blue;
  92                 alpha = color->alpha;
  93                 nalpha = 255 - alpha;
  94
  95                 *ptr = (((int)*ptr * nalpha) + (r * alpha)) / 256;
  96                 ptr++;
  97                 *ptr = (((int)*ptr * nalpha) + (g * alpha)) / 256;
  98                 ptr++;
  99                 *ptr = (((int)*ptr * nalpha) + (b * alpha)) / 256;
 100                 ptr++;
 101                 if (image->format == RRGBAFormat) {
 102                         *ptr = alpha + ((int)*ptr * nalpha) / 256;
 103                 }
 104         }
 105 }
 106
 107 static void operatePixel(RImage *image, int ofs, RPixelOperation operation, const RColor *color)
 108 {
 109         unsigned char *sr, *sg, *sb, *sa;
 110         register int alpha, nalpha, tmp;
 111         int hasAlpha = image->format == RRGBAFormat;
 112
 113         alpha = color->alpha;
 114         nalpha = 255 - alpha;
 115
 116         sr = image->data + ofs * (hasAlpha ? 4 : 3);
 117         sg = image->data + ofs * (hasAlpha ? 4 : 3) + 1;
 118         sb = image->data + ofs * (hasAlpha ? 4 : 3) + 2;
 119         sa = image->data + ofs * (hasAlpha ? 4 : 3) + 3;
 120
 121         switch (operation) {
 122         case RClearOperation:
 123                 *sr = 0;
 124                 *sg = 0;
 125                 *sb = 0;
 126                 if (hasAlpha)
 127                         *sa = 0;
 128                 break;
 129         case RCopyOperation:
 130                 *sr = color->red;
 131                 *sg = color->green;
 132                 *sb = color->blue;
 133                 if (hasAlpha)
 134                         *sa = color->alpha;
 135                 break;
 136         case RNormalOperation:
 137                 if (color->alpha == 255) {
 138                         *sr = color->red;
 139                         *sg = color->green;
 140                         *sb = color->blue;
 141                         if (hasAlpha)
 142                                 *sa = 255;
 143                 } else {
 144                         *sr = (((int)*sr * nalpha) + ((int)color->red * alpha)) / 256;
 145                         *sg = (((int)*sg * nalpha) + ((int)color->green * alpha)) / 256;
 146                         *sb = (((int)*sb * nalpha) + ((int)color->blue * alpha)) / 256;
 147                         *sa = alpha + ((int)*sa * nalpha) / 256;
 148                 }
 149                 break;
 150         case RAddOperation:
 151                 tmp = color->red + *sr;
 152                 *sr = MIN(255, tmp);
 153                 tmp = color->green + *sg;
 154                 *sg = MIN(255, tmp);
 155                 tmp = color->blue + *sb;
 156                 *sb = MIN(255, tmp);
 157                 if (hasAlpha)
 158                         *sa = MIN(*sa, color->alpha);
 159                 break;
 160         case RSubtractOperation:
 161                 tmp = *sr - color->red;
 162                 *sr = MAX(0, tmp);
 163                 tmp = *sg - color->green;
 164                 *sg = MAX(0, tmp);
 165                 tmp = *sb - color->blue;
 166                 *sb = MAX(0, tmp);
 167                 if (hasAlpha)
 168                         *sa = MIN(*sa, color->alpha);
 169                 break;
 170         }
 171 }
 172
 173 void ROperatePixel(RImage *image, RPixelOperation operation, int x, int y, const RColor *color)
 174 {
 175         int ofs;
 176
 177         assert(image != NULL);
 178         assert(color != NULL);
 179         assert(x >= 0 && x < image->width);
 180         assert(y >= 0 && y < image->height);
 181
 182         ofs = y * image->width + x;
 183
 184         operatePixel(image, ofs, operation, color);
 185 }
 186
 187 void RPutPixels(RImage *image, const RPoint *points, int npoints, RCoordinatesMode mode, const RColor *color)
 188 {
 189         register int x, y, i;
 190
 191         assert(image != NULL);
 192         assert(points != NULL);
 193
 194         x = y = 0;
 195
 196         for (i = 0; i < npoints; i++) {
 197                 if (mode == RAbsoluteCoordinates) {
 198                         x = points[i].x;
 199                         y = points[i].y;
 200                 } else {
 201                         x += points[i].x;
 202                         y += points[i].y;
 203                 }
 204                 RPutPixel(image, x, y, color);
 205         }
 206 }
 207
 208 void ROperatePixels(RImage *image, RPixelOperation operation,
 209                     const RPoint *points, int npoints, RCoordinatesMode mode,
 210                     const RColor *color)
 211 {
 212         register int x, y, i;
 213
 214         assert(image != NULL);
 215         assert(points != NULL);
 216
 217         x = y = 0;
 218
 219         for (i = 0; i < npoints; i++) {
 220                 if (mode == RAbsoluteCoordinates) {
 221                         x = points[i].x;
 222                         y = points[i].y;
 223                 } else {
 224                         x += points[i].x;
 225                         y += points[i].y;
 226                 }
 227                 ROperatePixel(image, operation, x, y, color);
 228         }
 229 }
 230
 231 static Bool clipLineInRectangle(int xmin, int ymin, int xmax, int ymax, int *x1, int *y1, int *x2, int *y2)
 232 {
 233 #define TOP     (1<<0)
 234 #define BOT     (1<<1)
 235 #define LEF     (1<<2)
 236 #define RIG     (1<<3)
 237 #define CHECK_OUT(X,Y)  (((Y) > ymax ? TOP : ((Y) < ymin ? BOT : 0))\
 238     | ((X) > xmax ? RIG : ((X) < xmin ? LEF : 0)))
 239
 240         int ocode1, ocode2, ocode;
 241         int accept = 0;
 242         int x, y;
 243
 244         ocode1 = CHECK_OUT(*x1, *y1);
 245         ocode2 = CHECK_OUT(*x2, *y2);
 246
 247         for (;;) {
 248                 if (!ocode1 && !ocode2) {       /* completely inside */
 249                         accept = 1;
 250                         break;
 251                 } else if (ocode1 & ocode2) {
 252                         break;
 253                 }
 254
 255                 if (ocode1)
 256                         ocode = ocode1;
 257                 else
 258                         ocode = ocode2;
 259
 260                 if (ocode & TOP) {
 261                         x = *x1 + (*x2 - *x1) * (ymax - *y1) / (*y2 - *y1);
 262                         y = ymax;
 263                 } else if (ocode & BOT) {
 264                         x = *x1 + (*x2 - *x1) * (ymin - *y1) / (*y2 - *y1);
 265                         y = ymin;
 266                 } else if (ocode & RIG) {
 267                         y = *y1 + (*y2 - *y1) * (xmax - *x1) / (*x2 - *x1);
 268                         x = xmax;
 269                 } else {        /* //if (ocode & LEF) { */
 270                         y = *y1 + (*y2 - *y1) * (xmax - *x1) / (*x2 - *x1);
 271                         x = xmin;
 272                 }
 273
 274                 if (ocode == ocode1) {
 275                         *x1 = x;
 276                         *y1 = y;
 277                         ocode1 = CHECK_OUT(x, y);
 278                 } else {
 279                         *x2 = x;
 280                         *y2 = y;
 281                         ocode2 = CHECK_OUT(x, y);
 282                 }
 283         }
 284
 285         return accept;
 286 }
 287
 288 /*
 289  * This routine is a generic drawing routine, based on Bresenham's line
 290  * drawing algorithm.
 291  */
 292 static int genericLine(RImage *image, int x0, int y0, int x1, int y1, const RColor *color,
 293                        RPixelOperation operation, int polyline)
 294 {
 295         int i, err, du, dv, du2, dv2, uofs, vofs, last;
 296
 297         assert(image != NULL);
 298
 299         if (!clipLineInRectangle(0, 0, image->width - 1, image->height - 1, &x0, &y0, &x1, &y1))
 300                 return True;
 301
 302         if (x0 < x1) {
 303                 du = x1 - x0;
 304                 uofs = 1;
 305         } else {
 306                 du = x0 - x1;
 307                 uofs = -1;
 308         }
 309         if (y0 < y1) {
 310                 dv = y1 - y0;
 311                 vofs = image->width;
 312         } else {
 313                 dv = y0 - y1;
 314                 vofs = -image->width;
 315         }
 316
 317         if (du < dv) {
 318                 /* Swap coordinates between them, so that always du>dv */
 319                 i = du;
 320                 du = dv;
 321                 dv = i;
 322                 i = uofs;
 323                 uofs = vofs;
 324                 vofs = i;
 325         }
 326
 327         err = 0;
 328         du2 = du << 1;
 329         dv2 = dv << 1;
 330         last = (polyline) ? du - 1 : du;
 331
 332         if (color->alpha == 255 || operation == RCopyOperation) {
 333                 unsigned char *ptr;
 334
 335                 if (image->format == RRGBAFormat)
 336                         i = (y0 * image->width + x0) * 4;
 337                 else
 338                         i = (y0 * image->width + x0) * 3;
 339                 ptr = image->data + i;
 340
 341                 for (i = 0; i <= last; i++) {
 342                         /* Draw the pixel */
 343                         *ptr = color->red;
 344                         *(ptr + 1) = color->green;
 345                         *(ptr + 2) = color->blue;
 346                         if (image->format == RRGBAFormat)
 347                                 *(ptr + 3) = 255;
 348
 349                         /* Compute error for NeXT Step */
 350                         err += dv2;
 351                         if (err >= du) {
 352                                 if (image->format == RRGBAFormat)
 353                                         ptr += vofs * 4;
 354                                 else
 355                                         ptr += vofs * 3;
 356                                 err -= du2;
 357                         }
 358                         if (image->format == RRGBAFormat)
 359                                 ptr += uofs * 4;
 360                         else
 361                                 ptr += uofs * 3;
 362                 }
 363         } else {
 364                 register int ofs = y0 * image->width + x0;
 365
 366                 for (i = 0; i <= last; i++) {
 367                         /* Draw the pixel */
 368                         operatePixel(image, ofs, operation, color);
 369
 370                         /* Compute error for NeXT Step */
 371                         err += dv2;
 372                         if (err >= du) {
 373                                 ofs += vofs;
 374                                 err -= du2;
 375                         }
 376                         ofs += uofs;
 377                 }
 378         }
 379
 380         return True;
 381 }
 382
 383 int RDrawLine(RImage * image, int x0, int y0, int x1, int y1, const RColor * color)
 384 {
 385         return genericLine(image, x0, y0, x1, y1, color, RNormalOperation, False);
 386 }
 387
 388 int ROperateLine(RImage *image, RPixelOperation operation, int x0, int y0, int x1, int y1, const RColor *color)
 389 {
 390         return genericLine(image, x0, y0, x1, y1, color, operation, False);
 391 }
 392
 393 void RDrawLines(RImage *image, const RPoint *points, int npoints, RCoordinatesMode mode, const RColor *color)
 394 {
 395         register int x1, y1, x2, y2, i;
 396
 397         assert(points != NULL);
 398
 399         if (npoints == 0)
 400                 return;
 401
 402         x1 = points[0].x;
 403         y1 = points[0].y;
 404         x2 = y2 = 0;
 405
 406         for (i = 1; i < npoints - 1; i++) {
 407                 if (mode == RAbsoluteCoordinates) {
 408                         x2 = points[i].x;
 409                         y2 = points[i].y;
 410                 } else {
 411                         x2 += points[i - 1].x;
 412                         y2 += points[i - 1].y;
 413                 }
 414                 /* Don't draw pixels at junction points twice */
 415                 genericLine(image, x1, y1, x2, y2, color, RNormalOperation, True);
 416                 x1 = x2;
 417                 y1 = y2;
 418         }
 419         i = npoints - 1;        /* last point */
 420         if (mode == RAbsoluteCoordinates) {
 421                 x2 = points[i].x;
 422                 y2 = points[i].y;
 423         } else {
 424                 x2 += points[i - 1].x;
 425                 y2 += points[i - 1].y;
 426         }
 427         i = (points[0].x == x2 && points[0].y == y2 && npoints > 1);
 428         genericLine(image, x1, y1, x2, y2, color, RNormalOperation, i);
 429 }
 430
 431 void ROperateLines(RImage *image, RPixelOperation operation,
 432                    const RPoint *points, int npoints, RCoordinatesMode mode,
 433                    const RColor *color)
 434 {
 435         register int x1, y1, x2, y2, i;
 436
 437         assert(points != NULL);
 438
 439         if (npoints == 0)
 440                 return;
 441
 442         x1 = points[0].x;
 443         y1 = points[0].y;
 444         x2 = y2 = 0;
 445
 446         for (i = 1; i < npoints - 1; i++) {
 447                 if (mode == RAbsoluteCoordinates) {
 448                         x2 = points[i].x;
 449                         y2 = points[i].y;
 450                 } else {
 451                         x2 += points[i - 1].x;
 452                         y2 += points[i - 1].y;
 453                 }
 454                 /* Don't draw pixels at junction points twice */
 455                 genericLine(image, x1, y1, x2, y2, color, operation, True);
 456                 x1 = x2;
 457                 y1 = y2;
 458         }
 459         i = npoints - 1;        /* last point */
 460         if (mode == RAbsoluteCoordinates) {
 461                 x2 = points[i].x;
 462                 y2 = points[i].y;
 463         } else {
 464                 x2 += points[i - 1].x;
 465                 y2 += points[i - 1].y;
 466         }
 467         i = (points[0].x == x2 && points[0].y == y2 && npoints > 1);
 468         genericLine(image, x1, y1, x2, y2, color, operation, i);
 469 }
 470
 471 void ROperateRectangle(RImage *image, RPixelOperation operation, int x0, int y0, int x1, int y1, const RColor *color)
 472 {
 473         int y;
 474
 475         for (y = y0; y <= y1; y++) {
 476                 genericLine(image, x0, y, x1, y, color, operation, False);
 477         }
 478 }
 479
 480 void RDrawSegments(RImage *image, const RSegment *segs, int nsegs, const RColor *color)
 481 {
 482         register int i;
 483
 484         assert(segs != NULL);
 485
 486         for (i = 0; i < nsegs; i++) {
 487                 genericLine(image, segs->x1, segs->y1, segs->x2, segs->y2, color, RNormalOperation, False);
 488                 segs++;
 489         }
 490 }
 491
 492 void ROperateSegments(RImage *image, RPixelOperation operation, const RSegment *segs, int nsegs, const RColor *color)
 493 {
 494         register int i;
 495
 496         assert(segs != NULL);
 497
 498         for (i = 0; i < nsegs; i++) {
 499                 genericLine(image, segs->x1, segs->y1, segs->x2, segs->y2, color, operation, False);
 500                 segs++;
 501         }
 502 }