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., 675 Mass Ave, Cambridge, MA 02139, USA.
  21  */
  22
  23 #include <config.h>
  24
  25 #include <stdio.h>
  26 #include <stdlib.h>
  27 #include <assert.h>
  28
  29 #include "wraster.h"
  30
  31 #define MIN(a,b)        ((a) < (b) ? (a) : (b))
  32 #define MAX(a,b)        ((a) > (b) ? (a) : (b))
  33
  34 /*
  35  * Returns the color of the pixel at coordinates (x, y) in "color".
  36  */
  37 Bool RGetPixel(RImage * image, int x, int y, RColor * color)
  38 {
  39         int ofs;
  40
  41         assert(image != NULL);
  42         if (x < 0 || x >= image->width || y < 0 || y >= image->height)
  43                 return False;
  44
  45         if (image->format == RRGBAFormat) {
  46                 ofs = (y * image->width + x) * 4;
  47                 color->red = image->data[ofs++];
  48                 color->green = image->data[ofs++];
  49                 color->blue = image->data[ofs++];
  50                 color->alpha = image->data[ofs];
  51         } else {
  52                 ofs = (y * image->width + x) * 3;
  53                 color->red = image->data[ofs++];
  54                 color->green = image->data[ofs++];
  55                 color->blue = image->data[ofs];
  56                 /* If the image does not have alpha channel, we consider alpha 255 */
  57                 color->alpha = 255;
  58         }
  59
  60         return True;
  61 }
  62
  63 void RPutPixel(RImage * image, int x, int y, RColor * color)
  64 {
  65         unsigned char *ptr;
  66
  67         assert(image != NULL);
  68         assert(color != NULL);
  69         if (x < 0 || x >= image->width || y < 0 || y >= image->height)
  70                 return;
  71
  72         if (image->format == RRGBAFormat) {
  73                 ptr = image->data + (y * image->width + x) * 4;
  74         } else {
  75                 ptr = image->data + (y * image->width + x) * 3;
  76         }
  77
  78         if (color->alpha == 255) {
  79                 *ptr++ = color->red;
  80                 *ptr++ = color->green;
  81                 *ptr++ = color->blue;
  82                 if (image->format == RRGBAFormat) {
  83                         *ptr = 255;
  84                 }
  85         } else {
  86                 register int alpha, nalpha, r, g, b;
  87
  88                 r = color->red;
  89                 g = color->green;
  90                 b = color->blue;
  91                 alpha = color->alpha;
  92                 nalpha = 255 - alpha;
  93
  94                 *ptr = (((int)*ptr * nalpha) + (r * alpha)) / 256;
  95                 ptr++;
  96                 *ptr = (((int)*ptr * nalpha) + (g * alpha)) / 256;
  97                 ptr++;
  98                 *ptr = (((int)*ptr * nalpha) + (b * alpha)) / 256;
  99                 ptr++;
 100                 if (image->format == RRGBAFormat) {
 101                         *ptr = alpha + ((int)*ptr * nalpha) / 256;
 102                 }
 103         }
 104 }
 105
 106 static void operatePixel(RImage * image, int ofs, int operation, RColor * color)
 107 {
 108         unsigned char *sr, *sg, *sb, *sa;
 109         register int alpha, nalpha, tmp;
 110         int hasAlpha = image->format == RRGBAFormat;
 111
 112         alpha = color->alpha;
 113         nalpha = 255 - alpha;
 114
 115         sr = image->data + ofs * (hasAlpha ? 4 : 3);
 116         sg = image->data + ofs * (hasAlpha ? 4 : 3) + 1;
 117         sb = image->data + ofs * (hasAlpha ? 4 : 3) + 2;
 118         sa = image->data + ofs * (hasAlpha ? 4 : 3) + 3;
 119
 120         switch (operation) {
 121         case RClearOperation:
 122                 *sr = 0;
 123                 *sg = 0;
 124                 *sb = 0;
 125                 if (hasAlpha)
 126                         *sa = 0;
 127                 break;
 128         case RCopyOperation:
 129                 *sr = color->red;
 130                 *sg = color->green;
 131                 *sb = color->blue;
 132                 if (hasAlpha)
 133                         *sa = color->alpha;
 134                 break;
 135         case RNormalOperation:
 136                 if (color->alpha == 255) {
 137                         *sr = color->red;
 138                         *sg = color->green;
 139                         *sb = color->blue;
 140                         if (hasAlpha)
 141                                 *sa = 255;
 142                 } else {
 143                         *sr = (((int)*sr * nalpha) + ((int)color->red * alpha)) / 256;
 144                         *sg = (((int)*sg * nalpha) + ((int)color->green * alpha)) / 256;
 145                         *sb = (((int)*sb * nalpha) + ((int)color->blue * alpha)) / 256;
 146                 }
 147                 break;
 148         case RAddOperation:
 149                 tmp = color->red + *sr;
 150                 *sr = MIN(255, tmp);
 151                 tmp = color->green + *sg;
 152                 *sg = MIN(255, tmp);
 153                 tmp = color->blue + *sb;
 154                 *sb = MIN(255, tmp);
 155                 if (hasAlpha)
 156                         *sa = MIN(*sa, color->alpha);
 157                 break;
 158         case RSubtractOperation:
 159                 tmp = *sr - color->red;
 160                 *sr = MAX(0, tmp);
 161                 tmp = *sg - color->green;
 162                 *sg = MAX(0, tmp);
 163                 tmp = *sb - color->blue;
 164                 *sb = MAX(0, tmp);
 165                 if (hasAlpha)
 166                         *sa = MIN(*sa, color->alpha);
 167                 break;
 168         }
 169 }
 170
 171 void ROperatePixel(RImage * image, int operation, int x, int y, RColor * color)
 172 {
 173         int ofs;
 174
 175         assert(image != NULL);
 176         assert(color != NULL);
 177         assert(x >= 0 && x < image->width);
 178         assert(y >= 0 && y < image->height);
 179
 180         ofs = y * image->width + x;
 181
 182         operatePixel(image, ofs, operation, color);
 183 }
 184
 185 void RPutPixels(RImage * image, RPoint * points, int npoints, int mode, RColor * color)
 186 {
 187         register int x, y, i;
 188
 189         assert(image != NULL);
 190         assert(points != NULL);
 191
 192         x = y = 0;
 193
 194         for (i = 0; i < npoints; i++) {
 195                 if (mode == RAbsoluteCoordinates) {
 196                         x = points[i].x;
 197                         y = points[i].y;
 198                 } else {
 199                         x += points[i].x;
 200                         y += points[i].y;
 201                 }
 202                 RPutPixel(image, x, y, color);
 203         }
 204 }
 205
 206 void ROperatePixels(RImage * image, int operation, RPoint * points, int npoints, int mode, RColor * color)
 207 {
 208         register int x, y, i;
 209
 210         assert(image != NULL);
 211         assert(points != NULL);
 212
 213         x = y = 0;
 214
 215         for (i = 0; i < npoints; i++) {
 216                 if (mode == RAbsoluteCoordinates) {
 217                         x = points[i].x;
 218                         y = points[i].y;
 219                 } else {
 220                         x += points[i].x;
 221                         y += points[i].y;
 222                 }
 223                 ROperatePixel(image, operation, x, y, color);
 224         }
 225 }
 226
 227 static Bool clipLineInRectangle(int xmin, int ymin, int xmax, int ymax, int *x1, int *y1, int *x2, int *y2)
 228 {
 229 #define TOP     (1<<0)
 230 #define BOT     (1<<1)
 231 #define LEF     (1<<2)
 232 #define RIG     (1<<3)
 233 #define CHECK_OUT(X,Y)  (((Y) > ymax ? TOP : ((Y) < ymin ? BOT : 0))\
 234     | ((X) > xmax ? RIG : ((X) < xmin ? LEF : 0)))
 235
 236         int ocode1, ocode2, ocode;
 237         int accept = 0;
 238         int x, y;
 239
 240         ocode1 = CHECK_OUT(*x1, *y1);
 241         ocode2 = CHECK_OUT(*x2, *y2);
 242
 243         for (;;) {
 244                 if (!ocode1 && !ocode2) {       /* completely inside */
 245                         accept = 1;
 246                         break;
 247                 } else if (ocode1 & ocode2) {
 248                         break;
 249                 }
 250
 251                 if (ocode1)
 252                         ocode = ocode1;
 253                 else
 254                         ocode = ocode2;
 255
 256                 if (ocode & TOP) {
 257                         x = *x1 + (*x2 - *x1) * (ymax - *y1) / (*y2 - *y1);
 258                         y = ymax;
 259                 } else if (ocode & BOT) {
 260                         x = *x1 + (*x2 - *x1) * (ymin - *y1) / (*y2 - *y1);
 261                         y = ymin;
 262                 } else if (ocode & RIG) {
 263                         y = *y1 + (*y2 - *y1) * (xmax - *x1) / (*x2 - *x1);
 264                         x = xmax;
 265                 } else {        /* //if (ocode & LEF) { */
 266                         y = *y1 + (*y2 - *y1) * (xmax - *x1) / (*x2 - *x1);
 267                         x = xmin;
 268                 }
 269
 270                 if (ocode == ocode1) {
 271                         *x1 = x;
 272                         *y1 = y;
 273                         ocode1 = CHECK_OUT(x, y);
 274                 } else {
 275                         *x2 = x;
 276                         *y2 = y;
 277                         ocode2 = CHECK_OUT(x, y);
 278                 }
 279         }
 280
 281         return accept;
 282 }
 283
 284 /*
 285  * This routine is a generic drawing routine, based on Bresenham's line
 286  * drawing algorithm.
 287  */
 288 static int genericLine(RImage * image, int x0, int y0, int x1, int y1, RColor * color, int operation, int polyline)
 289 {
 290         int i, err, du, dv, du2, dv2, uofs, vofs, last;
 291
 292         assert(image != NULL);
 293
 294         if (!clipLineInRectangle(0, 0, image->width - 1, image->height - 1, &x0, &y0, &x1, &y1))
 295                 return True;
 296
 297         if (x0 < x1) {
 298                 du = x1 - x0;
 299                 uofs = 1;
 300         } else {
 301                 du = x0 - x1;
 302                 uofs = -1;
 303         }
 304         if (y0 < y1) {
 305                 dv = y1 - y0;
 306                 vofs = image->width;
 307         } else {
 308                 dv = y0 - y1;
 309                 vofs = -image->width;
 310         }
 311
 312         if (du < dv) {
 313                 /* Swap coordinates between them, so that always du>dv */
 314                 i = du;
 315                 du = dv;
 316                 dv = i;
 317                 i = uofs;
 318                 uofs = vofs;
 319                 vofs = i;
 320         }
 321
 322         err = 0;
 323         du2 = du << 1;
 324         dv2 = dv << 1;
 325         last = (polyline) ? du - 1 : du;
 326
 327         if (color->alpha == 255 || operation == RCopyOperation) {
 328                 unsigned char *ptr;
 329
 330                 if (image->format == RRGBAFormat)
 331                         i = (y0 * image->width + x0) * 4;
 332                 else
 333                         i = (y0 * image->width + x0) * 3;
 334                 ptr = image->data + i;
 335
 336                 for (i = 0; i <= last; i++) {
 337                         /* Draw the pixel */
 338                         *ptr = color->red;
 339                         *(ptr + 1) = color->green;
 340                         *(ptr + 2) = color->blue;
 341                         if (image->format == RRGBAFormat)
 342                                 *(ptr + 3) = 255;
 343
 344                         /* Compute error for NeXT Step */
 345                         err += dv2;
 346                         if (err >= du) {
 347                                 if (image->format == RRGBAFormat)
 348                                         ptr += vofs * 4;
 349                                 else
 350                                         ptr += vofs * 3;
 351                                 err -= du2;
 352                         }
 353                         if (image->format == RRGBAFormat)
 354                                 ptr += uofs * 4;
 355                         else
 356                                 ptr += uofs * 3;
 357                 }
 358         } else {
 359                 register int ofs = y0 * image->width + x0;
 360
 361                 for (i = 0; i <= last; i++) {
 362                         /* Draw the pixel */
 363                         operatePixel(image, ofs, operation, color);
 364
 365                         /* Compute error for NeXT Step */
 366                         err += dv2;
 367                         if (err >= du) {
 368                                 ofs += vofs;
 369                                 err -= du2;
 370                         }
 371                         ofs += uofs;
 372                 }
 373         }
 374
 375 #if 0
 376         if (mode == RALTER_PIXELS) {
 377                 RColorOffset *cdelta = (RColorOffset *) cdata;
 378                 register short r, g, b, a;
 379
 380                 for (i = 0; i <= last; i++) {
 381                         /* Change the pixel with offset */
 382                         r = (short)*sr + cdelta->red;
 383                         g = (short)*sg + cdelta->green;
 384                         b = (short)*sb + cdelta->blue;
 385                         if (r > 255)
 386                                 r = 255;
 387                         else if (r < 0)
 388                                 r = 0;
 389                         if (g > 255)
 390                                 g = 255;
 391                         else if (g < 0)
 392                                 g = 0;
 393                         if (b > 255)
 394                                 b = 255;
 395                         else if (b < 0)
 396                                 b = 0;
 397                         *sr = (unsigned char)r;
 398                         *sg = (unsigned char)g;
 399                         *sb = (unsigned char)b;
 400                         if (image->data[3]) {
 401                                 a = (short)*sa + cdelta->alpha;
 402                                 if (a > 255)
 403                                         a = 255;
 404                                 else if (a < 0)
 405                                         a = 0;
 406                                 *sa = (unsigned char)a;
 407                         }
 408
 409                         /* Compute error for NeXT Step */
 410                         err += dv2;
 411                         if (err >= du) {
 412                                 sr += vofs;
 413                                 sg += vofs;
 414                                 sb += vofs;
 415                                 sa += vofs;
 416                                 err -= du2;
 417                         }
 418                         sr += uofs;
 419                         sg += uofs;
 420                         sb += uofs;
 421                         sa += uofs;
 422                 }
 423         } else {
 424                 RColor *color = (RColor *) cdata;
 425
 426                 if (color->alpha == 255) {
 427                         for (i = 0; i <= last; i++) {
 428                                 /* Draw the pixel */
 429                                 *sr = color->red;
 430                                 *sg = color->green;
 431                                 *sb = color->blue;
 432                                 if (image->data[3])
 433                                         *sa = 255;
 434
 435                                 /* Compute error for NeXT Step */
 436                                 err += dv2;
 437                                 if (err >= du) {
 438                                         sr += vofs;
 439                                         sg += vofs;
 440                                         sb += vofs;
 441                                         sa += vofs;
 442                                         err -= du2;
 443                                 }
 444                                 sr += uofs;
 445                                 sg += uofs;
 446                                 sb += uofs;
 447                                 sa += uofs;
 448                         }
 449                 } else {
 450                         register short alpha, nalpha, r, g, b;
 451
 452                         alpha = color->alpha;
 453                         nalpha = 255 - alpha;
 454                         r = color->red;
 455                         g = color->green;
 456                         b = color->blue;
 457
 458                         for (i = 0; i <= last; i++) {
 459                                 /* Draw the pixel */
 460                                 *sr = (((int)*sr * nalpha) + (r * alpha)) / 256;
 461                                 *sg = (((int)*sg * nalpha) + (g * alpha)) / 256;
 462                                 *sb = (((int)*sb * nalpha) + (b * alpha)) / 256;
 463                                 if (image->data[3])
 464                                         *sa = alpha + ((int)*sa * nalpha) / 256;
 465
 466                                 /* Compute error for NeXT Step */
 467                                 err += dv2;
 468                                 if (err >= du) {
 469                                         sr += vofs;
 470                                         sg += vofs;
 471                                         sb += vofs;
 472                                         sa += vofs;
 473                                         err -= du2;
 474                                 }
 475                                 sr += uofs;
 476                                 sg += uofs;
 477                                 sb += uofs;
 478                                 sa += uofs;
 479                         }
 480                 }
 481         }
 482 #endif
 483         return True;
 484 }
 485
 486 int RDrawLine(RImage * image, int x0, int y0, int x1, int y1, RColor * color)
 487 {
 488         return genericLine(image, x0, y0, x1, y1, color, RNormalOperation, False);
 489 }
 490
 491 int ROperateLine(RImage * image, int operation, int x0, int y0, int x1, int y1, RColor * color)
 492 {
 493         return genericLine(image, x0, y0, x1, y1, color, operation, False);
 494 }
 495
 496 void RDrawLines(RImage * image, RPoint * points, int npoints, int mode, RColor * color)
 497 {
 498         register int x1, y1, x2, y2, i;
 499
 500         assert(points != NULL);
 501
 502         if (npoints == 0)
 503                 return;
 504
 505         x1 = points[0].x;
 506         y1 = points[0].y;
 507         x2 = y2 = 0;
 508
 509         for (i = 1; i < npoints - 1; i++) {
 510                 if (mode == RAbsoluteCoordinates) {
 511                         x2 = points[i].x;
 512                         y2 = points[i].y;
 513                 } else {
 514                         x2 += points[i - 1].x;
 515                         y2 += points[i - 1].y;
 516                 }
 517                 /* Don't draw pixels at junction points twice */
 518                 genericLine(image, x1, y1, x2, y2, color, RNormalOperation, True);
 519                 x1 = x2;
 520                 y1 = y2;
 521         }
 522         i = npoints - 1;        /* last point */
 523         if (mode == RAbsoluteCoordinates) {
 524                 x2 = points[i].x;
 525                 y2 = points[i].y;
 526         } else {
 527                 x2 += points[i - 1].x;
 528                 y2 += points[i - 1].y;
 529         }
 530         i = (points[0].x == x2 && points[0].y == y2 && npoints > 1);
 531         genericLine(image, x1, y1, x2, y2, color, RNormalOperation, i);
 532 }
 533
 534 void ROperateLines(RImage * image, int operation, RPoint * points, int npoints, int mode, RColor * color)
 535 {
 536         register int x1, y1, x2, y2, i;
 537
 538         assert(points != NULL);
 539
 540         if (npoints == 0)
 541                 return;
 542
 543         x1 = points[0].x;
 544         y1 = points[0].y;
 545         x2 = y2 = 0;
 546
 547         for (i = 1; i < npoints - 1; i++) {
 548                 if (mode == RAbsoluteCoordinates) {
 549                         x2 = points[i].x;
 550                         y2 = points[i].y;
 551                 } else {
 552                         x2 += points[i - 1].x;
 553                         y2 += points[i - 1].y;
 554                 }
 555                 /* Don't draw pixels at junction points twice */
 556                 genericLine(image, x1, y1, x2, y2, color, operation, True);
 557                 x1 = x2;
 558                 y1 = y2;
 559         }
 560         i = npoints - 1;        /* last point */
 561         if (mode == RAbsoluteCoordinates) {
 562                 x2 = points[i].x;
 563                 y2 = points[i].y;
 564         } else {
 565                 x2 += points[i - 1].x;
 566                 y2 += points[i - 1].y;
 567         }
 568         i = (points[0].x == x2 && points[0].y == y2 && npoints > 1);
 569         genericLine(image, x1, y1, x2, y2, color, operation, i);
 570 }
 571
 572 void RDrawSegments(RImage * image, RSegment * segs, int nsegs, RColor * color)
 573 {
 574         register int i;
 575
 576         assert(segs != NULL);
 577
 578         for (i = 0; i < nsegs; i++) {
 579                 genericLine(image, segs->x1, segs->y1, segs->x2, segs->y2, color, RNormalOperation, False);
 580                 segs++;
 581         }
 582 }
 583
 584 void ROperateSegments(RImage * image, int operation, RSegment * segs, int nsegs, RColor * color)
 585 {
 586         register int i;
 587
 588         assert(segs != NULL);
 589
 590         for (i = 0; i < nsegs; i++) {
 591                 genericLine(image, segs->x1, segs->y1, segs->x2, segs->y2, color, operation, False);
 592                 segs++;
 593         }
 594 }