libraries/libart_lgpl-2.3.7/art_render_gradient.c

   1 /*
   2  * art_render_gradient.c: Gradient image source for modular rendering.
   3  *
   4  * Libart_LGPL - library of basic graphic primitives
   5  * Copyright (C) 2000 Raph Levien
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Library General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Library General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Library General Public
  18  * License along with this library; if not, write to the
  19  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  20  * Boston, MA 02111-1307, USA.
  21  *
  22  * Authors: Raph Levien <raph@acm.org>
  23  *          Alexander Larsson <alla@lysator.liu.se>
  24  */
  25
  26 #include <math.h>
  27
  28 #include "art_misc.h"
  29 #include "art_alphagamma.h"
  30 #include "art_filterlevel.h"
  31
  32 #include "art_render.h"
  33 #include "art_render_gradient.h"
  34
  35 typedef struct _ArtImageSourceGradLin ArtImageSourceGradLin;
  36 typedef struct _ArtImageSourceGradRad ArtImageSourceGradRad;
  37
  38 struct _ArtImageSourceGradLin {
  39   ArtImageSource super;
  40   const ArtGradientLinear *gradient;
  41 };
  42
  43 struct _ArtImageSourceGradRad {
  44   ArtImageSource super;
  45   const ArtGradientRadial *gradient;
  46   double a;
  47 };
  48
  49 #define EPSILON 1e-6
  50
  51 /**
  52  * art_render_gradient_setpix: Set a gradient pixel.
  53  * @render: The render object.
  54  * @dst: Pointer to destination (where to store pixel).
  55  * @n_stops: Number of stops in @stops.
  56  * @stops: The stops for the gradient.
  57  * @offset: The offset.
  58  *
  59  * @n_stops must be > 0.
  60  *
  61  * Sets a gradient pixel, storing it at @dst.
  62  **/
  63 static void
  64 art_render_gradient_setpix (ArtRender *render,
  65                             art_u8 *dst,
  66                             int n_stops, ArtGradientStop *stops,
  67                             double offset)
  68 {
  69   int ix;
  70   int j;
  71   double off0, off1;
  72   int n_ch = render->n_chan + 1;
  73
  74   for (ix = 0; ix < n_stops; ix++)
  75     if (stops[ix].offset > offset)
  76       break;
  77   /* stops[ix - 1].offset < offset < stops[ix].offset */
  78   if (ix > 0 && ix < n_stops)
  79     {
  80       off0 = stops[ix - 1].offset;
  81       off1 = stops[ix].offset;
  82       if (fabs (off1 - off0) > EPSILON)
  83         {
  84           double interp;
  85
  86           interp = (offset - off0) / (off1 - off0);
  87           for (j = 0; j < n_ch; j++)
  88             {
  89               int z0, z1;
  90               int z;
  91               z0 = stops[ix - 1].color[j];
  92               z1 = stops[ix].color[j];
  93               z = floor (z0 + (z1 - z0) * interp + 0.5);
  94               if (render->buf_depth == 8)
  95                 dst[j] = ART_PIX_8_FROM_MAX (z);
  96               else /* (render->buf_depth == 16) */
  97                 ((art_u16 *)dst)[j] = z;
  98             }
  99           return;
 100         }
 101     }
 102   else if (ix == n_stops)
 103     ix--;
 104
 105   for (j = 0; j < n_ch; j++)
 106     {
 107       int z;
 108       z = stops[ix].color[j];
 109       if (render->buf_depth == 8)
 110         dst[j] = ART_PIX_8_FROM_MAX (z);
 111       else /* (render->buf_depth == 16) */
 112         ((art_u16 *)dst)[j] = z;
 113     }
 114 }
 115
 116 static void
 117 art_render_gradient_linear_done (ArtRenderCallback *self, ArtRender *render)
 118 {
 119   art_free (self);
 120 }
 121
 122 static void
 123 art_render_gradient_linear_render (ArtRenderCallback *self, ArtRender *render,
 124                                    art_u8 *dest, int y)
 125 {
 126   ArtImageSourceGradLin *z = (ArtImageSourceGradLin *)self;
 127   const ArtGradientLinear *gradient = z->gradient;
 128   int pixstride = (render->n_chan + 1) * (render->depth >> 3);
 129   int x;
 130   int width = render->x1 - render->x0;
 131   double offset, d_offset;
 132   double actual_offset;
 133   int n_stops = gradient->n_stops;
 134   ArtGradientStop *stops = gradient->stops;
 135   art_u8 *bufp = render->image_buf;
 136   ArtGradientSpread spread = gradient->spread;
 137
 138   offset = render->x0 * gradient->a + y * gradient->b + gradient->c;
 139   d_offset = gradient->a;
 140
 141   for (x = 0; x < width; x++)
 142     {
 143       if (spread == ART_GRADIENT_PAD)
 144         actual_offset = offset;
 145       else if (spread == ART_GRADIENT_REPEAT)
 146         actual_offset = offset - floor (offset);
 147       else /* (spread == ART_GRADIENT_REFLECT) */
 148         {
 149           double tmp;
 150
 151           tmp = offset - 2 * floor (0.5 * offset);
 152           actual_offset = tmp > 1 ? 2 - tmp : tmp;
 153         }
 154       art_render_gradient_setpix (render, bufp, n_stops, stops, actual_offset);
 155       offset += d_offset;
 156       bufp += pixstride;
 157     }
 158 }
 159
 160 static void
 161 art_render_gradient_linear_negotiate (ArtImageSource *self, ArtRender *render,
 162                                       ArtImageSourceFlags *p_flags,
 163                                       int *p_buf_depth, ArtAlphaType *p_alpha)
 164 {
 165   self->super.render = art_render_gradient_linear_render;
 166   *p_flags = 0;
 167   *p_buf_depth = render->depth;
 168   *p_alpha = ART_ALPHA_PREMUL;
 169 }
 170
 171 /**
 172  * art_render_gradient_linear: Add a linear gradient image source.
 173  * @render: The render object.
 174  * @gradient: The linear gradient.
 175  *
 176  * Adds the linear gradient @gradient as the image source for rendering
 177  * in the render object @render.
 178  **/
 179 void
 180 art_render_gradient_linear (ArtRender *render,
 181                             const ArtGradientLinear *gradient,
 182                             ArtFilterLevel level)
 183 {
 184   ArtImageSourceGradLin *image_source = art_new (ArtImageSourceGradLin, 1);
 185
 186   image_source->super.super.render = NULL;
 187   image_source->super.super.done = art_render_gradient_linear_done;
 188   image_source->super.negotiate = art_render_gradient_linear_negotiate;
 189
 190   image_source->gradient = gradient;
 191
 192   art_render_add_image_source (render, &image_source->super);
 193 }
 194
 195 static void
 196 art_render_gradient_radial_done (ArtRenderCallback *self, ArtRender *render)
 197 {
 198   art_free (self);
 199 }
 200
 201 static void
 202 art_render_gradient_radial_render (ArtRenderCallback *self, ArtRender *render,
 203                                    art_u8 *dest, int y)
 204 {
 205   ArtImageSourceGradRad *z = (ArtImageSourceGradRad *)self;
 206   const ArtGradientRadial *gradient = z->gradient;
 207   int pixstride = (render->n_chan + 1) * (render->depth >> 3);
 208   int x;
 209   int x0 = render->x0;
 210   int width = render->x1 - x0;
 211   int n_stops = gradient->n_stops;
 212   ArtGradientStop *stops = gradient->stops;
 213   art_u8 *bufp = render->image_buf;
 214   double fx = gradient->fx;
 215   double fy = gradient->fy;
 216   double dx, dy;
 217   double *affine = gradient->affine;
 218   double aff0 = affine[0];
 219   double aff1 = affine[1];
 220   const double a = z->a;
 221   const double arecip = 1.0 / a;
 222   double b, db;
 223   double c, dc, ddc;
 224   double b_a, db_a;
 225   double rad, drad, ddrad;
 226
 227   dx = x0 * aff0 + y * affine[2] + affine[4] - fx;
 228   dy = x0 * aff1 + y * affine[3] + affine[5] - fy;
 229   b = dx * fx + dy * fy;
 230   db = aff0 * fx + aff1 * fy;
 231   c = dx * dx + dy * dy;
 232   dc = 2 * aff0 * dx + aff0 * aff0 + 2 * aff1 * dy + aff1 * aff1;
 233   ddc = 2 * aff0 * aff0 + 2 * aff1 * aff1;
 234
 235   b_a = b * arecip;
 236   db_a = db * arecip;
 237
 238   rad = b_a * b_a + c * arecip;
 239   drad = 2 * b_a * db_a + db_a * db_a + dc * arecip;
 240   ddrad = 2 * db_a * db_a + ddc * arecip;
 241
 242   for (x = 0; x < width; x++)
 243     {
 244       double z;
 245
 246       if (rad > 0)
 247         z = b_a + sqrt (rad);
 248       else
 249         z = b_a;
 250       art_render_gradient_setpix (render, bufp, n_stops, stops, z);
 251       bufp += pixstride;
 252       b_a += db_a;
 253       rad += drad;
 254       drad += ddrad;
 255     }
 256 }
 257
 258 static void
 259 art_render_gradient_radial_negotiate (ArtImageSource *self, ArtRender *render,
 260                                       ArtImageSourceFlags *p_flags,
 261                                       int *p_buf_depth, ArtAlphaType *p_alpha)
 262 {
 263   self->super.render = art_render_gradient_radial_render;
 264   *p_flags = 0;
 265   *p_buf_depth = render->depth;
 266   *p_alpha = ART_ALPHA_PREMUL;
 267 }
 268
 269 /**
 270  * art_render_gradient_radial: Add a radial gradient image source.
 271  * @render: The render object.
 272  * @gradient: The radial gradient.
 273  *
 274  * Adds the radial gradient @gradient as the image source for rendering
 275  * in the render object @render.
 276  **/
 277 void
 278 art_render_gradient_radial (ArtRender *render,
 279                             const ArtGradientRadial *gradient,
 280                             ArtFilterLevel level)
 281 {
 282   ArtImageSourceGradRad *image_source = art_new (ArtImageSourceGradRad, 1);
 283   double fx = gradient->fx;
 284   double fy = gradient->fy;
 285
 286   image_source->super.super.render = NULL;
 287   image_source->super.super.done = art_render_gradient_radial_done;
 288   image_source->super.negotiate = art_render_gradient_radial_negotiate;
 289
 290   image_source->gradient = gradient;
 291   /* todo: sanitycheck fx, fy? */
 292   image_source->a = 1 - fx * fx - fy * fy;
 293
 294   art_render_add_image_source (render, &image_source->super);
 295 }