← Back to branch summary

~ubuntu-branches/ubuntu/jaunty/gimp/jaunty-security

« back to all changes in this revision

Viewing changes to app/base/lut-funcs.c

  • Committer: Bazaar Package Importer
  • Author(s): Daniel Holbach
  • Date: 2007-05-02 16:33:03 UTC
  • mfrom: (1.1.4 upstream)
  • Revision ID: james.westby@ubuntu.com-20070502163303-bvzhjzbpw8qglc4y
Tags: 2.3.16-1ubuntu1
* Resynchronized with Debian, remaining Ubuntu changes:
  - debian/rules: i18n magic.
* debian/control.in:
  - Maintainer: Ubuntu Core Developers <ubuntu-devel@lists.ubuntu.com>
* debian/patches/02_help-message.patch,
  debian/patches/03_gimp.desktop.in.in.patch,
  debian/patches/10_dont_show_wizard.patch: updated.
* debian/patches/04_composite-signedness.patch,
  debian/patches/05_add-letter-spacing.patch: dropped, used upstream.

Show diffs side-by-side

added added

removed removed

Lines of Context:
app/base/lut-funcs.c
1
 
/* The GIMP -- an image manipulation program
 
1
/* GIMP - The GNU Image Manipulation Program
2
2
 * Copyright (C) 1995 Spencer Kimball and Peter Mattis
3
3
 *
4
4
 * This program is free software; you can redistribute it and/or modify
31
31
 
32
32
/* ---------- Brightness/Contrast -----------*/
33
33
 
34
 
typedef struct B_C_struct
 
34
typedef struct
35
35
{
36
36
  gdouble brightness;
37
37
  gdouble contrast;
38
 
} B_C_struct;
 
38
} BrightnessContrastLutData;
39
39
 
40
40
static gfloat
41
 
brightness_contrast_lut_func (B_C_struct *data,
42
 
                              gint        nchannels,
43
 
                              gint        channel,
44
 
                              gfloat      value)
 
41
brightness_contrast_lut_func (BrightnessContrastLutData *data,
 
42
                              gint                       nchannels,
 
43
                              gint                       channel,
 
44
                              gfloat                     value)
45
45
{
46
 
  gfloat  nvalue;
47
 
  gdouble power;
 
46
  gdouble slant;
48
47
 
49
48
  /* return the original value for the alpha channel */
50
49
  if ((nchannels == 2 || nchannels == 4) && channel == nchannels -1)
56
55
  else
57
56
    value = value + ((1.0 - value) * data->brightness);
58
57
 
59
 
  /* apply contrast */
60
 
  if (data->contrast < 0.0)
61
 
    {
62
 
      if (value > 0.5)
63
 
        nvalue = 1.0 - value;
64
 
      else
65
 
        nvalue = value;
66
 
 
67
 
      if (nvalue < 0.0)
68
 
        nvalue = 0.0;
69
 
 
70
 
      nvalue = 0.5 * pow (nvalue * 2.0 , (double) (1.0 + data->contrast));
71
 
 
72
 
      if (value > 0.5)
73
 
        value = 1.0 - nvalue;
74
 
      else
75
 
        value = nvalue;
76
 
    }
77
 
  else
78
 
    {
79
 
      if (value > 0.5)
80
 
        nvalue = 1.0 - value;
81
 
      else
82
 
        nvalue = value;
83
 
 
84
 
      if (nvalue < 0.0)
85
 
        nvalue = 0.0;
86
 
 
87
 
      power = (data->contrast == 1.0) ? 127 : 1.0 / (1.0 - data->contrast);
88
 
      nvalue = 0.5 * pow (2.0 * nvalue, power);
89
 
 
90
 
      if (value > 0.5)
91
 
        value = 1.0 - nvalue;
92
 
      else
93
 
        value = nvalue;
94
 
    }
 
58
  slant = tan ((data->contrast + 1) * G_PI_4);
 
59
  value = (value - 0.5) * slant + 0.5;
95
60
 
96
61
  return value;
97
62
}
98
63
 
99
 
GimpLut *
100
 
brightness_contrast_lut_new (gdouble brightness,
101
 
                             gdouble contrast,
102
 
                             gint    n_channels)
103
 
{
104
 
  GimpLut *lut;
105
 
 
106
 
  lut = gimp_lut_new ();
107
 
 
108
 
  brightness_contrast_lut_setup (lut, brightness, contrast, n_channels);
109
 
 
110
 
  return lut;
111
 
}
112
 
 
113
64
void
114
65
brightness_contrast_lut_setup (GimpLut *lut,
115
 
                               gdouble  brightness,
116
 
                               gdouble  contrast,
117
 
                               gint     n_channels)
 
66
                               gdouble  brightness,
 
67
                               gdouble  contrast,
 
68
                               gint     n_channels)
118
69
{
119
 
  B_C_struct data;
 
70
  BrightnessContrastLutData data;
120
71
 
121
72
  g_return_if_fail (lut != NULL);
122
73
 
124
75
  data.contrast   = contrast;
125
76
 
126
77
  gimp_lut_setup (lut, (GimpLutFunc) brightness_contrast_lut_func,
127
 
                  (gpointer) &data, n_channels);
 
78
                  (gpointer) &data, n_channels);
 
79
}
 
80
 
 
81
GimpLut *
 
82
brightness_contrast_lut_new (gdouble brightness,
 
83
                             gdouble contrast,
 
84
                             gint    n_channels)
 
85
{
 
86
  GimpLut *lut = gimp_lut_new ();
 
87
 
 
88
  brightness_contrast_lut_setup (lut, brightness, contrast, n_channels);
 
89
 
 
90
  return lut;
128
91
}
129
92
 
130
93
/* ---------------- invert ------------------ */
131
94
 
132
95
static gfloat
133
96
invert_lut_func (gpointer  unused,
134
 
                 gint      n_channels,
135
 
                 gint      channel,
136
 
                 gfloat    value)
 
97
                 gint      n_channels,
 
98
                 gint      channel,
 
99
                 gfloat    value)
137
100
{
138
101
  /* don't invert the alpha channel */
139
102
  if ((n_channels == 2 || n_channels == 4) && channel == n_channels -1)
142
105
  return 1.0 - value;
143
106
}
144
107
 
 
108
static void
 
109
invert_lut_setup (GimpLut *lut,
 
110
                  gint     n_channels)
 
111
{
 
112
  g_return_if_fail (lut != NULL);
 
113
 
 
114
  gimp_lut_setup_exact (lut, (GimpLutFunc) invert_lut_func,
 
115
                        NULL , n_channels);
 
116
}
 
117
 
145
118
GimpLut *
146
119
invert_lut_new (gint n_channels)
147
120
{
148
 
  GimpLut *lut;
149
 
 
150
 
  lut = gimp_lut_new ();
 
121
  GimpLut *lut = gimp_lut_new ();
151
122
 
152
123
  invert_lut_setup (lut, n_channels);
153
124
 
154
125
  return lut;
155
126
}
156
127
 
157
 
void
158
 
invert_lut_setup (GimpLut *lut,
159
 
                  gint     n_channels)
160
 
{
161
 
  g_return_if_fail (lut != NULL);
162
 
 
163
 
  gimp_lut_setup_exact (lut, (GimpLutFunc) invert_lut_func,
164
 
                        NULL , n_channels);
165
 
}
166
 
 
167
128
/* ---------------- add (or subract)------------------ */
168
129
 
169
130
static gfloat
170
131
add_lut_func (gdouble *amount,
171
 
              gint     n_channels,
172
 
              gint     channel,
173
 
              gfloat   value)
 
132
              gint     n_channels,
 
133
              gint     channel,
 
134
              gfloat   value)
174
135
{
175
136
  /* don't change the alpha channel */
176
137
  if ((n_channels == 2 || n_channels == 4) && channel == n_channels -1)
179
140
  return (value + *amount);
180
141
}
181
142
 
 
143
static void
 
144
add_lut_setup (GimpLut *lut,
 
145
               gdouble  amount,
 
146
               gint     n_channels)
 
147
{
 
148
  g_return_if_fail (lut != NULL);
 
149
 
 
150
  gimp_lut_setup (lut, (GimpLutFunc) add_lut_func,
 
151
                  (gpointer) &amount, n_channels);
 
152
}
 
153
 
182
154
GimpLut *
183
155
add_lut_new (gdouble amount,
184
 
             gint    n_channels)
 
156
             gint    n_channels)
185
157
{
186
 
  GimpLut *lut;
187
 
 
188
 
  lut = gimp_lut_new ();
 
158
  GimpLut *lut = gimp_lut_new ();
189
159
 
190
160
  add_lut_setup (lut, amount, n_channels);
191
161
 
192
162
  return lut;
193
163
}
194
164
 
195
 
void
196
 
add_lut_setup (GimpLut *lut,
197
 
               gdouble  amount,
198
 
               gint     n_channels)
199
 
{
200
 
  g_return_if_fail (lut != NULL);
201
 
 
202
 
  gimp_lut_setup (lut, (GimpLutFunc) add_lut_func,
203
 
                  (gpointer) &amount, n_channels);
204
 
}
205
 
 
206
165
/* ---------------- intersect (MIN (pixel, value)) ------------------ */
207
166
 
208
167
static gfloat
209
168
intersect_lut_func (gdouble *min,
210
 
                    gint     n_channels,
211
 
                    gint     channel,
212
 
                    gfloat   value)
 
169
                    gint     n_channels,
 
170
                    gint     channel,
 
171
                    gfloat   value)
213
172
{
214
173
  /* don't change the alpha channel */
215
174
  if ((n_channels == 2 || n_channels == 4) && channel == n_channels -1)
218
177
  return MIN (value, *min);
219
178
}
220
179
 
 
180
static void
 
181
intersect_lut_setup (GimpLut *lut,
 
182
                     gdouble  value,
 
183
                     gint     n_channels)
 
184
{
 
185
  g_return_if_fail (lut != NULL);
 
186
 
 
187
  gimp_lut_setup_exact (lut, (GimpLutFunc) intersect_lut_func,
 
188
                        (gpointer) &value , n_channels);
 
189
}
 
190
 
221
191
GimpLut *
222
192
intersect_lut_new (gdouble value,
223
 
                   gint    n_channels)
 
193
                   gint    n_channels)
224
194
{
225
 
  GimpLut *lut;
226
 
 
227
 
  lut = gimp_lut_new ();
 
195
  GimpLut *lut = gimp_lut_new ();
228
196
 
229
197
  intersect_lut_setup (lut, value, n_channels);
230
198
 
231
199
  return lut;
232
200
}
233
201
 
234
 
void
235
 
intersect_lut_setup (GimpLut *lut,
236
 
                     gdouble  value,
237
 
                     gint     n_channels)
238
 
{
239
 
  g_return_if_fail (lut != NULL);
240
 
 
241
 
  gimp_lut_setup_exact (lut, (GimpLutFunc) intersect_lut_func,
242
 
                        (gpointer) &value , n_channels);
243
 
}
244
 
 
245
202
/* ---------------- Threshold ------------------ */
246
203
 
247
204
static gfloat
248
205
threshold_lut_func (gdouble *min,
249
 
                    gint     n_channels,
250
 
                    gint     channel,
251
 
                    gfloat   value)
 
206
                    gint     n_channels,
 
207
                    gint     channel,
 
208
                    gfloat   value)
252
209
{
253
210
  /* don't change the alpha channel */
254
211
  if ((n_channels == 2 || n_channels == 4) && channel == n_channels -1)
260
217
  return 1.0;
261
218
}
262
219
 
 
220
static void
 
221
threshold_lut_setup (GimpLut *lut,
 
222
                     gdouble  value,
 
223
                     gint     n_channels)
 
224
{
 
225
  g_return_if_fail (lut != NULL);
 
226
 
 
227
  gimp_lut_setup_exact (lut, (GimpLutFunc) threshold_lut_func,
 
228
                        (gpointer) &value , n_channels);
 
229
}
 
230
 
263
231
GimpLut *
264
232
threshold_lut_new (gdouble value,
265
 
                   gint    n_channels)
 
233
                   gint    n_channels)
266
234
{
267
 
  GimpLut *lut;
268
 
 
269
 
  lut = gimp_lut_new ();
 
235
  GimpLut *lut = gimp_lut_new ();
270
236
 
271
237
  threshold_lut_setup (lut, value, n_channels);
272
238
 
273
239
  return lut;
274
240
}
275
241
 
276
 
void
277
 
threshold_lut_setup (GimpLut *lut,
278
 
                     gdouble  value,
279
 
                     gint     n_channels)
280
 
{
281
 
  g_return_if_fail (lut != NULL);
282
 
 
283
 
  gimp_lut_setup_exact (lut, (GimpLutFunc) threshold_lut_func,
284
 
                        (gpointer) &value , n_channels);
285
 
}
286
 
 
287
242
/* --------------- posterize ---------------- */
288
243
 
289
244
static gfloat
290
245
posterize_lut_func (gint   *ilevels,
291
 
                    gint    n_channels,
292
 
                    gint    channel,
293
 
                    gfloat  value)
 
246
                    gint    n_channels,
 
247
                    gint    channel,
 
248
                    gfloat  value)
294
249
{
295
250
  gint levels;
296
251
 
308
263
  return value;
309
264
}
310
265
 
 
266
void
 
267
posterize_lut_setup (GimpLut *lut,
 
268
                     gint     levels,
 
269
                     gint     n_channels)
 
270
{
 
271
  g_return_if_fail (lut != NULL);
 
272
 
 
273
  gimp_lut_setup_exact (lut, (GimpLutFunc) posterize_lut_func,
 
274
                        (gpointer) &levels, n_channels);
 
275
}
 
276
 
311
277
GimpLut *
312
278
posterize_lut_new (gint levels,
313
 
                   gint n_channels)
 
279
                   gint n_channels)
314
280
{
315
 
  GimpLut *lut;
316
 
 
317
 
  lut = gimp_lut_new ();
 
281
  GimpLut *lut = gimp_lut_new ();
318
282
 
319
283
  posterize_lut_setup (lut, levels, n_channels);
320
284
 
321
285
  return lut;
322
286
}
323
287
 
324
 
void
325
 
posterize_lut_setup (GimpLut *lut,
326
 
                     gint     levels,
327
 
                     gint     n_channels)
328
 
{
329
 
  g_return_if_fail (lut != NULL);
330
 
 
331
 
  gimp_lut_setup_exact (lut, (GimpLutFunc) posterize_lut_func,
332
 
                        (gpointer) &levels, n_channels);
333
 
}
334
 
 
335
288
/* --------------- equalize ------------- */
336
289
 
337
290
typedef struct
342
295
 
343
296
static gfloat
344
297
equalize_lut_func (hist_lut_struct *hlut,
345
 
                   gint             n_channels,
346
 
                   gint             channel,
347
 
                   gfloat           value)
 
298
                   gint             n_channels,
 
299
                   gint             channel,
 
300
                   gfloat           value)
348
301
{
349
302
  gint i = 0;
350
303
  gint j;
357
310
  return i / 255.0;
358
311
}
359
312
 
360
 
GimpLut *
361
 
eq_histogram_lut_new (GimpHistogram *histogram,
362
 
                      gint           n_channels)
363
 
{
364
 
  GimpLut *lut;
365
 
 
366
 
  g_return_val_if_fail (histogram != NULL, NULL);
367
 
 
368
 
  lut = gimp_lut_new ();
369
 
 
370
 
  eq_histogram_lut_setup (lut, histogram, n_channels);
371
 
 
372
 
  return lut;
373
 
}
374
 
 
375
 
void
376
 
eq_histogram_lut_setup (GimpLut       *lut,
377
 
                        GimpHistogram *hist,
378
 
                        gint           n_channels)
 
313
static void
 
314
equalize_lut_setup (GimpLut       *lut,
 
315
                    GimpHistogram *hist,
 
316
                    gint           n_channels)
379
317
{
380
318
  gint            i, k, j;
381
319
  hist_lut_struct hlut;
400
338
      /* Find intermediate points */
401
339
      j   = 0;
402
340
      sum = (gimp_histogram_get_channel (hist, k, 0) +
403
 
             gimp_histogram_get_channel (hist, k, 1));
 
341
             gimp_histogram_get_channel (hist, k, 1));
404
342
 
405
343
      for (i = 1; i < 256; i++)
406
 
        {
407
 
          desired = i * pixels_per_value;
408
 
 
409
 
          while (sum <= desired)
410
 
            {
411
 
              j++;
412
 
              sum += gimp_histogram_get_channel (hist, k, j + 1);
413
 
            }
414
 
 
415
 
          /* Nearest sum */
416
 
          dif = sum - gimp_histogram_get_channel (hist, k, j);
417
 
 
418
 
          if ((sum - desired) > (dif / 2.0))
419
 
            hlut.part[k][i] = j;
420
 
          else
421
 
            hlut.part[k][i] = j + 1;
422
 
        }
 
344
        {
 
345
          desired = i * pixels_per_value;
 
346
 
 
347
          while (sum <= desired)
 
348
            {
 
349
              j++;
 
350
              sum += gimp_histogram_get_channel (hist, k, j + 1);
 
351
            }
 
352
 
 
353
          /* Nearest sum */
 
354
          dif = sum - gimp_histogram_get_channel (hist, k, j);
 
355
 
 
356
          if ((sum - desired) > (dif / 2.0))
 
357
            hlut.part[k][i] = j;
 
358
          else
 
359
            hlut.part[k][i] = j + 1;
 
360
        }
423
361
    }
424
362
 
425
363
  gimp_lut_setup (lut, (GimpLutFunc) equalize_lut_func,
426
 
                  (gpointer) &hlut, n_channels);
 
364
                  (gpointer) &hlut, n_channels);
 
365
}
 
366
 
 
367
GimpLut *
 
368
equalize_lut_new (GimpHistogram *histogram,
 
369
                  gint           n_channels)
 
370
{
 
371
  GimpLut *lut;
 
372
 
 
373
  g_return_val_if_fail (histogram != NULL, NULL);
 
374
 
 
375
  lut = gimp_lut_new ();
 
376
 
 
377
  equalize_lut_setup (lut, histogram, n_channels);
 
378
 
 
379
  return lut;
427
380
}