wrlib/gradient.c

   1 /* gradient.c - renders gradients
   2  *
   3  * Raster graphics library
   4  *
   5  * Copyright (c) 1997-2003 Alfredo K. Kojima
   6  * Copyright (c) 1998-2003 Dan Pascu
   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 <stdlib.h>
  26 #include <stdio.h>
  27 #include <string.h>
  28
  29 #include <assert.h>
  30
  31 #include "wraster.h"
  32
  33 static RImage *renderHGradient(unsigned width, unsigned height, int r0, int g0, int b0, int rf, int gf, int bf);
  34 static RImage *renderVGradient(unsigned width, unsigned height, int r0, int g0, int b0, int rf, int gf, int bf);
  35 static RImage *renderDGradient(unsigned width, unsigned height, int r0, int g0, int b0, int rf, int gf, int bf);
  36
  37 static RImage *renderMHGradient(unsigned width, unsigned height, RColor ** colors, int count);
  38 static RImage *renderMVGradient(unsigned width, unsigned height, RColor ** colors, int count);
  39 static RImage *renderMDGradient(unsigned width, unsigned height, RColor ** colors, int count);
  40
  41 RImage *RRenderMultiGradient(unsigned width, unsigned height, RColor ** colors, int style)
  42 {
  43         int count;
  44
  45         count = 0;
  46         while (colors[count] != NULL)
  47                 count++;
  48
  49         if (count > 2) {
  50                 switch (style) {
  51                 case RHorizontalGradient:
  52                         return renderMHGradient(width, height, colors, count);
  53                 case RVerticalGradient:
  54                         return renderMVGradient(width, height, colors, count);
  55                 case RDiagonalGradient:
  56                         return renderMDGradient(width, height, colors, count);
  57                 }
  58         } else if (count > 1) {
  59                 return RRenderGradient(width, height, colors[0], colors[1], style);
  60         } else if (count > 0) {
  61                 return RRenderGradient(width, height, colors[0], colors[0], style);
  62         }
  63         assert(0);
  64         return NULL;
  65 }
  66
  67 RImage *RRenderGradient(unsigned width, unsigned height, RColor * from, RColor * to, int style)
  68 {
  69         switch (style) {
  70         case RHorizontalGradient:
  71                 return renderHGradient(width, height, from->red, from->green,
  72                                        from->blue, to->red, to->green, to->blue);
  73         case RVerticalGradient:
  74                 return renderVGradient(width, height, from->red, from->green,
  75                                        from->blue, to->red, to->green, to->blue);
  76
  77         case RDiagonalGradient:
  78                 return renderDGradient(width, height, from->red, from->green,
  79                                        from->blue, to->red, to->green, to->blue);
  80         }
  81         assert(0);
  82         return NULL;
  83 }
  84
  85 /*
  86  *----------------------------------------------------------------------
  87  * renderHGradient--
  88  *      Renders a horizontal linear gradient of the specified size in the
  89  * RImage format with a border of the specified type.
  90  *
  91  * Returns:
  92  *      A 24bit RImage with the gradient (no alpha channel).
  93  *
  94  * Side effects:
  95  *      None
  96  *----------------------------------------------------------------------
  97  */
  98 static RImage *renderHGradient(unsigned width, unsigned height, int r0, int g0, int b0, int rf, int gf, int bf)
  99 {
 100         int i;
 101         long r, g, b, dr, dg, db;
 102         unsigned lineSize = width * 3;
 103         RImage *image;
 104         unsigned char *ptr;
 105
 106         image = RCreateImage(width, height, False);
 107         if (!image) {
 108                 return NULL;
 109         }
 110         ptr = image->data;
 111
 112         r = r0 << 16;
 113         g = g0 << 16;
 114         b = b0 << 16;
 115
 116         dr = ((rf - r0) << 16) / (int)width;
 117         dg = ((gf - g0) << 16) / (int)width;
 118         db = ((bf - b0) << 16) / (int)width;
 119         /* render the first line */
 120         for (i = 0; i < width; i++) {
 121                 *(ptr++) = (unsigned char)(r >> 16);
 122                 *(ptr++) = (unsigned char)(g >> 16);
 123                 *(ptr++) = (unsigned char)(b >> 16);
 124                 r += dr;
 125                 g += dg;
 126                 b += db;
 127         }
 128
 129         /* copy the first line to the other lines */
 130         for (i = 1; i < height; i++) {
 131                 memcpy(&(image->data[i * lineSize]), image->data, lineSize);
 132         }
 133         return image;
 134 }
 135
 136 /*
 137  *----------------------------------------------------------------------
 138  * renderVGradient--
 139  *      Renders a vertical linear gradient of the specified size in the
 140  * RImage format with a border of the specified type.
 141  *
 142  * Returns:
 143  *      A 24bit RImage with the gradient (no alpha channel).
 144  *
 145  * Side effects:
 146  *      None
 147  *----------------------------------------------------------------------
 148  */
 149 static RImage *renderVGradient(unsigned width, unsigned height, int r0, int g0, int b0, int rf, int gf, int bf)
 150 {
 151         int i, j;
 152         long r, g, b, dr, dg, db;
 153         RImage *image;
 154         unsigned char *ptr;
 155         unsigned char rr, gg, bb;
 156
 157         image = RCreateImage(width, height, False);
 158         if (!image) {
 159                 return NULL;
 160         }
 161         ptr = image->data;
 162
 163         r = r0 << 16;
 164         g = g0 << 16;
 165         b = b0 << 16;
 166
 167         dr = ((rf - r0) << 16) / (int)height;
 168         dg = ((gf - g0) << 16) / (int)height;
 169         db = ((bf - b0) << 16) / (int)height;
 170
 171         for (i = 0; i < height; i++) {
 172                 rr = r >> 16;
 173                 gg = g >> 16;
 174                 bb = b >> 16;
 175                 for (j = 0; j < width / 8; j++) {
 176                         *(ptr++) = rr;
 177                         *(ptr++) = gg;
 178                         *(ptr++) = bb;
 179                         *(ptr++) = rr;
 180                         *(ptr++) = gg;
 181                         *(ptr++) = bb;
 182                         *(ptr++) = rr;
 183                         *(ptr++) = gg;
 184                         *(ptr++) = bb;
 185                         *(ptr++) = rr;
 186                         *(ptr++) = gg;
 187                         *(ptr++) = bb;
 188                         *(ptr++) = rr;
 189                         *(ptr++) = gg;
 190                         *(ptr++) = bb;
 191                         *(ptr++) = rr;
 192                         *(ptr++) = gg;
 193                         *(ptr++) = bb;
 194                         *(ptr++) = rr;
 195                         *(ptr++) = gg;
 196                         *(ptr++) = bb;
 197                         *(ptr++) = rr;
 198                         *(ptr++) = gg;
 199                         *(ptr++) = bb;
 200                 }
 201                 switch (width % 8) {
 202                 case 7:
 203                         *(ptr++) = rr;
 204                         *(ptr++) = gg;
 205                         *(ptr++) = bb;
 206                 case 6:
 207                         *(ptr++) = rr;
 208                         *(ptr++) = gg;
 209                         *(ptr++) = bb;
 210                 case 5:
 211                         *(ptr++) = rr;
 212                         *(ptr++) = gg;
 213                         *(ptr++) = bb;
 214                 case 4:
 215                         *(ptr++) = rr;
 216                         *(ptr++) = gg;
 217                         *(ptr++) = bb;
 218                 case 3:
 219                         *(ptr++) = rr;
 220                         *(ptr++) = gg;
 221                         *(ptr++) = bb;
 222                 case 2:
 223                         *(ptr++) = rr;
 224                         *(ptr++) = gg;
 225                         *(ptr++) = bb;
 226                 case 1:
 227                         *(ptr++) = rr;
 228                         *(ptr++) = gg;
 229                         *(ptr++) = bb;
 230                 }
 231                 r += dr;
 232                 g += dg;
 233                 b += db;
 234         }
 235         return image;
 236 }
 237
 238 /*
 239  *----------------------------------------------------------------------
 240  * renderDGradient--
 241  *      Renders a diagonal linear gradient of the specified size in the
 242  * RImage format with a border of the specified type.
 243  *
 244  * Returns:
 245  *      A 24bit RImage with the gradient (no alpha channel).
 246  *
 247  * Side effects:
 248  *      None
 249  *----------------------------------------------------------------------
 250  */
 251
 252 static RImage *renderDGradient(unsigned width, unsigned height, int r0, int g0, int b0, int rf, int gf, int bf)
 253 {
 254         RImage *image, *tmp;
 255         int j;
 256         float a, offset;
 257         unsigned char *ptr;
 258
 259         if (width == 1)
 260                 return renderVGradient(width, height, r0, g0, b0, rf, gf, bf);
 261         else if (height == 1)
 262                 return renderHGradient(width, height, r0, g0, b0, rf, gf, bf);
 263
 264         image = RCreateImage(width, height, False);
 265         if (!image) {
 266                 return NULL;
 267         }
 268
 269         tmp = renderHGradient(2 * width - 1, 1, r0, g0, b0, rf, gf, bf);
 270         if (!tmp) {
 271                 RReleaseImage(image);
 272                 return NULL;
 273         }
 274
 275         ptr = tmp->data;
 276
 277         a = ((float)(width - 1)) / ((float)(height - 1));
 278         width = width * 3;
 279
 280         /* copy the first line to the other lines with corresponding offset */
 281         for (j = 0, offset = 0.0; j < width * height; j += width) {
 282                 memcpy(&(image->data[j]), &ptr[3 * (int)offset], width);
 283                 offset += a;
 284         }
 285
 286         RReleaseImage(tmp);
 287         return image;
 288 }
 289
 290 static RImage *renderMHGradient(unsigned width, unsigned height, RColor ** colors, int count)
 291 {
 292         int i, j, k;
 293         long r, g, b, dr, dg, db;
 294         unsigned lineSize = width * 3;
 295         RImage *image;
 296         unsigned char *ptr;
 297         unsigned width2;
 298
 299         assert(count > 2);
 300
 301         image = RCreateImage(width, height, False);
 302         if (!image) {
 303                 return NULL;
 304         }
 305         ptr = image->data;
 306
 307         if (count > width)
 308                 count = width;
 309
 310         if (count > 1)
 311                 width2 = width / (count - 1);
 312         else
 313                 width2 = width;
 314
 315         k = 0;
 316
 317         r = colors[0]->red << 16;
 318         g = colors[0]->green << 16;
 319         b = colors[0]->blue << 16;
 320
 321         /* render the first line */
 322         for (i = 1; i < count; i++) {
 323                 dr = ((int)(colors[i]->red - colors[i - 1]->red) << 16) / (int)width2;
 324                 dg = ((int)(colors[i]->green - colors[i - 1]->green) << 16) / (int)width2;
 325                 db = ((int)(colors[i]->blue - colors[i - 1]->blue) << 16) / (int)width2;
 326                 for (j = 0; j < width2; j++) {
 327                         *ptr++ = (unsigned char)(r >> 16);
 328                         *ptr++ = (unsigned char)(g >> 16);
 329                         *ptr++ = (unsigned char)(b >> 16);
 330                         r += dr;
 331                         g += dg;
 332                         b += db;
 333                         k++;
 334                 }
 335                 r = colors[i]->red << 16;
 336                 g = colors[i]->green << 16;
 337                 b = colors[i]->blue << 16;
 338         }
 339         for (j = k; j < width; j++) {
 340                 *ptr++ = (unsigned char)(r >> 16);
 341                 *ptr++ = (unsigned char)(g >> 16);
 342                 *ptr++ = (unsigned char)(b >> 16);
 343         }
 344
 345         /* copy the first line to the other lines */
 346         for (i = 1; i < height; i++) {
 347                 memcpy(&(image->data[i * lineSize]), image->data, lineSize);
 348         }
 349         return image;
 350 }
 351
 352 static RImage *renderMVGradient(unsigned width, unsigned height, RColor ** colors, int count)
 353 {
 354         int i, j, k;
 355         long r, g, b, dr, dg, db;
 356         unsigned lineSize = width * 3;
 357         RImage *image;
 358         unsigned char *ptr, *tmp;
 359         unsigned height2;
 360         int x;
 361         unsigned char rr, gg, bb;
 362
 363         assert(count > 2);
 364
 365         image = RCreateImage(width, height, False);
 366         if (!image) {
 367                 return NULL;
 368         }
 369         ptr = image->data;
 370
 371         if (count > height)
 372                 count = height;
 373
 374         if (count > 1)
 375                 height2 = height / (count - 1);
 376         else
 377                 height2 = height;
 378
 379         k = 0;
 380
 381         r = colors[0]->red << 16;
 382         g = colors[0]->green << 16;
 383         b = colors[0]->blue << 16;
 384
 385         for (i = 1; i < count; i++) {
 386                 dr = ((int)(colors[i]->red - colors[i - 1]->red) << 16) / (int)height2;
 387                 dg = ((int)(colors[i]->green - colors[i - 1]->green) << 16) / (int)height2;
 388                 db = ((int)(colors[i]->blue - colors[i - 1]->blue) << 16) / (int)height2;
 389
 390                 for (j = 0; j < height2; j++) {
 391                         rr = r >> 16;
 392                         gg = g >> 16;
 393                         bb = b >> 16;
 394
 395                         for (x = 0; x < width / 4; x++) {
 396                                 *ptr++ = rr;
 397                                 *ptr++ = gg;
 398                                 *ptr++ = bb;
 399                                 *ptr++ = rr;
 400                                 *ptr++ = gg;
 401                                 *ptr++ = bb;
 402                                 *ptr++ = rr;
 403                                 *ptr++ = gg;
 404                                 *ptr++ = bb;
 405                                 *ptr++ = rr;
 406                                 *ptr++ = gg;
 407                                 *ptr++ = bb;
 408                         }
 409                         switch (width % 4) {
 410                         case 3:
 411                                 *ptr++ = rr;
 412                                 *ptr++ = gg;
 413                                 *ptr++ = bb;
 414                         case 2:
 415                                 *ptr++ = rr;
 416                                 *ptr++ = gg;
 417                                 *ptr++ = bb;
 418                         case 1:
 419                                 *ptr++ = rr;
 420                                 *ptr++ = gg;
 421                                 *ptr++ = bb;
 422                         }
 423                         r += dr;
 424                         g += dg;
 425                         b += db;
 426                         k++;
 427                 }
 428                 r = colors[i]->red << 16;
 429                 g = colors[i]->green << 16;
 430                 b = colors[i]->blue << 16;
 431         }
 432
 433         rr = r >> 16;
 434         gg = g >> 16;
 435         bb = b >> 16;
 436
 437         if (k < height) {
 438                 tmp = ptr;
 439                 for (x = 0; x < width / 4; x++) {
 440                         *ptr++ = rr;
 441                         *ptr++ = gg;
 442                         *ptr++ = bb;
 443                         *ptr++ = rr;
 444                         *ptr++ = gg;
 445                         *ptr++ = bb;
 446                         *ptr++ = rr;
 447                         *ptr++ = gg;
 448                         *ptr++ = bb;
 449                         *ptr++ = rr;
 450                         *ptr++ = gg;
 451                         *ptr++ = bb;
 452                 }
 453                 switch (width % 4) {
 454                 case 3:
 455                         *ptr++ = rr;
 456                         *ptr++ = gg;
 457                         *ptr++ = bb;
 458                 case 2:
 459                         *ptr++ = rr;
 460                         *ptr++ = gg;
 461                         *ptr++ = bb;
 462                 case 1:
 463                         *ptr++ = rr;
 464                         *ptr++ = gg;
 465                         *ptr++ = bb;
 466                 default:
 467                         break;
 468                 }
 469
 470                 for (j = k + 1; j < height; j++) {
 471                         memcpy(ptr, tmp, lineSize);
 472                         ptr += lineSize;
 473                 }
 474         }
 475
 476         return image;
 477 }
 478
 479 static RImage *renderMDGradient(unsigned width, unsigned height, RColor ** colors, int count)
 480 {
 481         RImage *image, *tmp;
 482         float a, offset;
 483         int j;
 484         unsigned char *ptr;
 485
 486         assert(count > 2);
 487
 488         if (width == 1)
 489                 return renderMVGradient(width, height, colors, count);
 490         else if (height == 1)
 491                 return renderMHGradient(width, height, colors, count);
 492
 493         image = RCreateImage(width, height, False);
 494         if (!image) {
 495                 return NULL;
 496         }
 497
 498         if (count > width)
 499                 count = width;
 500         if (count > height)
 501                 count = height;
 502
 503         if (count > 2)
 504                 tmp = renderMHGradient(2 * width - 1, 1, colors, count);
 505         else
 506                 tmp = renderHGradient(2 * width - 1, 1, colors[0]->red << 8,
 507                                       colors[0]->green << 8, colors[0]->blue << 8,
 508                                       colors[1]->red << 8, colors[1]->green << 8, colors[1]->blue << 8);
 509
 510         if (!tmp) {
 511                 RReleaseImage(image);
 512                 return NULL;
 513         }
 514         ptr = tmp->data;
 515
 516         a = ((float)(width - 1)) / ((float)(height - 1));
 517         width = width * 3;
 518
 519         /* copy the first line to the other lines with corresponding offset */
 520         for (j = 0, offset = 0; j < width * height; j += width) {
 521                 memcpy(&(image->data[j]), &ptr[3 * (int)offset], width);
 522                 offset += a;
 523         }
 524         RReleaseImage(tmp);
 525         return image;
 526 }
 527
 528 RImage *RRenderInterwovenGradient(unsigned width, unsigned height,
 529                                   RColor colors1[2], int thickness1, RColor colors2[2], int thickness2)
 530 {
 531         int i, j, k, l, ll;
 532         long r1, g1, b1, dr1, dg1, db1;
 533         long r2, g2, b2, dr2, dg2, db2;
 534         RImage *image;
 535         unsigned char *ptr;
 536         unsigned char rr, gg, bb;
 537
 538         image = RCreateImage(width, height, False);
 539         if (!image) {
 540                 return NULL;
 541         }
 542         ptr = image->data;
 543
 544         r1 = colors1[0].red << 16;
 545         g1 = colors1[0].green << 16;
 546         b1 = colors1[0].blue << 16;
 547
 548         r2 = colors2[0].red << 16;
 549         g2 = colors2[0].green << 16;
 550         b2 = colors2[0].blue << 16;
 551
 552         dr1 = ((colors1[1].red - colors1[0].red) << 16) / (int)height;
 553         dg1 = ((colors1[1].green - colors1[0].green) << 16) / (int)height;
 554         db1 = ((colors1[1].blue - colors1[0].blue) << 16) / (int)height;
 555
 556         dr2 = ((colors2[1].red - colors2[0].red) << 16) / (int)height;
 557         dg2 = ((colors2[1].green - colors2[0].green) << 16) / (int)height;
 558         db2 = ((colors2[1].blue - colors2[0].blue) << 16) / (int)height;
 559
 560         for (i = 0, k = 0, l = 0, ll = thickness1; i < height; i++) {
 561                 if (k == 0) {
 562                         rr = r1 >> 16;
 563                         gg = g1 >> 16;
 564                         bb = b1 >> 16;
 565                 } else {
 566                         rr = r2 >> 16;
 567                         gg = g2 >> 16;
 568                         bb = b2 >> 16;
 569                 }
 570                 for (j = 0; j < width / 8; j++) {
 571                         *(ptr++) = rr;
 572                         *(ptr++) = gg;
 573                         *(ptr++) = bb;
 574                         *(ptr++) = rr;
 575                         *(ptr++) = gg;
 576                         *(ptr++) = bb;
 577                         *(ptr++) = rr;
 578                         *(ptr++) = gg;
 579                         *(ptr++) = bb;
 580                         *(ptr++) = rr;
 581                         *(ptr++) = gg;
 582                         *(ptr++) = bb;
 583                         *(ptr++) = rr;
 584                         *(ptr++) = gg;
 585                         *(ptr++) = bb;
 586                         *(ptr++) = rr;
 587                         *(ptr++) = gg;
 588                         *(ptr++) = bb;
 589                         *(ptr++) = rr;
 590                         *(ptr++) = gg;
 591                         *(ptr++) = bb;
 592                         *(ptr++) = rr;
 593                         *(ptr++) = gg;
 594                         *(ptr++) = bb;
 595                 }
 596                 switch (width % 8) {
 597                 case 7:
 598                         *(ptr++) = rr;
 599                         *(ptr++) = gg;
 600                         *(ptr++) = bb;
 601                 case 6:
 602                         *(ptr++) = rr;
 603                         *(ptr++) = gg;
 604                         *(ptr++) = bb;
 605                 case 5:
 606                         *(ptr++) = rr;
 607                         *(ptr++) = gg;
 608                         *(ptr++) = bb;
 609                 case 4:
 610                         *(ptr++) = rr;
 611                         *(ptr++) = gg;
 612                         *(ptr++) = bb;
 613                 case 3:
 614                         *(ptr++) = rr;
 615                         *(ptr++) = gg;
 616                         *(ptr++) = bb;
 617                 case 2:
 618                         *(ptr++) = rr;
 619                         *(ptr++) = gg;
 620                         *(ptr++) = bb;
 621                 case 1:
 622                         *(ptr++) = rr;
 623                         *(ptr++) = gg;
 624                         *(ptr++) = bb;
 625                 }
 626                 if (++l == ll) {
 627                         if (k == 0) {
 628                                 k = 1;
 629                                 ll = thickness2;
 630                         } else {
 631                                 k = 0;
 632                                 ll = thickness1;
 633                         }
 634                         l = 0;
 635                 }
 636                 r1 += dr1;
 637                 g1 += dg1;
 638                 b1 += db1;
 639
 640                 r2 += dr2;
 641                 g2 += dg2;
 642                 b2 += db2;
 643         }
 644         return image;
 645 }