avoid an unneeded check in the FT1 has_chars() method implementation
[imager.git] / convert.im
1 /*
2 =head1 NAME
3
4   convert.im - image conversions
5
6 =head1 SYNOPSIS
7
8   out = i_convert(srcimage, coeff, outchans, inchans)
9
10 =head1 DESCRIPTION
11
12 Converts images from one format to another, typically in this case for
13 converting from RGBA to greyscale and back.
14
15 =over
16
17 =cut
18 */
19
20 #define IMAGER_NO_CONTEXT
21 #include "imager.h"
22
23 struct chan_copy {
24   /* channels to copy */
25   int copy_count;
26   int from[MAXCHANNELS];
27   int to[MAXCHANNELS];
28
29   /* channels to zero */
30   int zero_count;
31   int zero[MAXCHANNELS];
32
33   /* channels to set to maxsample */
34   int one_count;
35   int one[MAXCHANNELS];
36 };
37
38 static int 
39 is_channel_copy(i_img *im, const double *coeff, 
40                 int outchan, int inchan, 
41                 struct chan_copy *info);
42
43 static i_img *
44 convert_via_copy(i_img *im, i_img *src, struct chan_copy *info);
45
46 /*
47 =item i_convert(src, coeff, outchan, inchan)
48
49 Converts the image src into another image.
50
51 coeff contains the co-efficients of an outchan x inchan matrix, for
52 each output pixel:
53
54               coeff[0], coeff[1] ...
55   im[x,y] = [ coeff[inchan], coeff[inchan+1]...        ] * [ src[x,y], 1]
56               ...              coeff[inchan*outchan-1]
57
58 If im has the wrong number of channels or is the wrong size then
59 i_convert() will re-create it.
60
61 Now handles images with more than 8-bits/sample.
62
63 =cut
64 */
65
66 i_img *
67 i_convert(i_img *src, const double *coeff, int outchan, int inchan) {
68   double work[MAXCHANNELS];
69   i_img_dim x, y;
70   int i, j;
71   int ilimit;
72   i_img *im = NULL;
73   dIMCTXim(src);
74
75   im_log((aIMCTX,1,"i_convert(im %p, src %p, coeff %p,outchan %d, inchan %d)\n",
76           im, src, coeff, outchan, inchan));
77  
78   im_clear_error(aIMCTX);
79
80   ilimit = inchan;
81   if (ilimit > src->channels)
82     ilimit = src->channels;
83   if (outchan > MAXCHANNELS) {
84     im_push_error(aIMCTX, 0, "cannot have outchan > MAXCHANNELS");
85     return 0;
86   }
87
88   if (src->type == i_direct_type) {
89     struct chan_copy info;
90     im = i_sametype_chans(src, src->xsize, src->ysize, outchan);
91     
92     if (is_channel_copy(src, coeff, outchan, inchan, &info)) {
93       return convert_via_copy(im, src, &info);
94     }
95     else {
96 #code src->bits <= i_8_bits
97       IM_COLOR *vals;
98       
99       /* we can always allocate a single scanline of i_color */
100       vals = mymalloc(sizeof(IM_COLOR) * src->xsize); /* checked 04Jul05 tonyc */
101       for (y = 0; y < src->ysize; ++y) {
102         IM_GLIN(src, 0, src->xsize, y, vals);
103         for (x = 0; x < src->xsize; ++x) {
104           for (j = 0; j < outchan; ++j) {
105             work[j] = 0;
106             for (i = 0; i < ilimit; ++i) {
107               work[j] += coeff[i+inchan*j] * vals[x].channel[i];
108             }
109             if (i < inchan) {
110               work[j] += coeff[i+inchan*j] * IM_SAMPLE_MAX;
111             }
112           }
113           for (j = 0; j < outchan; ++j) {
114             if (work[j] < 0)
115               vals[x].channel[j] = 0;
116             else if (work[j] >= IM_SAMPLE_MAX)
117               vals[x].channel[j] = IM_SAMPLE_MAX;
118             else
119               vals[x].channel[j] = work[j];
120           }
121         }
122         IM_PLIN(im, 0, src->xsize, y, vals);
123       }
124       myfree(vals);
125 #/code
126     }
127   }
128   else {
129     int count;
130     int outcount;
131     int index;
132     i_color *colors;
133     i_palidx *vals;
134
135     im = im_img_pal_new(aIMCTX, src->xsize, src->ysize, outchan, 
136                         i_maxcolors(src));
137
138     /* just translate the color table */
139     count = i_colorcount(src);
140     outcount = i_colorcount(im);
141     /* color table allocated for image, so it must fit */
142     colors = mymalloc(count * sizeof(i_color)); /* check 04Jul05 tonyc */
143     i_getcolors(src, 0, colors, count);
144     for (index = 0; index < count; ++index) {
145       for (j = 0; j < outchan; ++j) {
146         work[j] = 0;
147         for (i = 0; i < ilimit; ++i) {
148           work[j] += coeff[i+inchan*j] * colors[index].channel[i];
149         }
150         if (i < inchan) {
151           work[j] += coeff[i+inchan*j] * 255.9;
152         }
153       }
154       for (j = 0; j < outchan; ++j) {
155         if (work[j] < 0)
156           colors[index].channel[j] = 0;
157         else if (work[j] >= 255)
158           colors[index].channel[j] = 255;
159         else
160           colors[index].channel[j] = work[j];
161       }
162     }
163     if (count < outcount) {
164       i_setcolors(im, 0, colors, count);
165     }
166     else {
167       i_setcolors(im, 0, colors, outcount);
168       i_addcolors(im, colors, count-outcount);
169     }
170     /* and copy the indicies */
171     /* i_palidx is always unsigned char and will never be bigger than short
172        and since a line of 4-byte i_colors can fit then a line of i_palidx
173        will fit */
174     vals = mymalloc(sizeof(i_palidx) * im->xsize); /* checked 4jul05 tonyc */
175     for (y = 0; y < im->ysize; ++y) {
176       i_gpal(src, 0, im->xsize, y, vals);
177       i_ppal(im, 0, im->xsize, y, vals);
178     }
179     myfree(vals);
180     myfree(colors);
181   }
182
183   return im;
184 }
185
186 /*
187 =item is_channel_copy(coeff, outchan, inchan, chan_copy_info)
188
189 Test if the coefficients represent just copying channels around, and
190 initialize lists of the channels to copy, zero or set to max.
191
192 =cut
193 */
194
195 static
196 int is_channel_copy(i_img *im, const double *coeff, int outchan, int inchan, 
197                     struct chan_copy *info) {
198   int srcchan[MAXCHANNELS];
199   int onechan[MAXCHANNELS];
200   int i, j;
201   int ilimit = im->channels > inchan ? inchan : im->channels;
202
203   for (j = 0; j < outchan; ++j) {
204     srcchan[j] = -1;
205     onechan[j] = 0;
206   }
207
208   for (j = 0; j < outchan; ++j) {
209     for (i = 0; i < ilimit; ++i) {
210       if (coeff[i+inchan*j] == 1.0) {
211         if (srcchan[j] != -1) {
212           /* from two or more channels, not a copy */
213           return 0;
214         }
215         srcchan[j] = i;
216       }
217       else if (coeff[i+inchan*j]) {
218         /* some other non-zero value, not a copy */
219         return 0;
220       }
221     }
222     if (i < inchan) {
223       if (coeff[i+inchan*j] == 1.0) {
224         if (srcchan[j] != -1) {
225           /* can't do both */
226           return 0;
227         }
228         onechan[j] = 1;
229       }
230       else if (coeff[i+inchan*j]) {
231         /* some other non-zero value, not a copy */
232         return 0;
233       }
234     }
235   }
236
237   /* build our working data structures */
238   info->copy_count = info->zero_count = info->one_count = 0;
239   for (j = 0; j < outchan; ++j) {
240     if (srcchan[j] != -1) {
241       info->from[info->copy_count] = srcchan[j];
242       info->to[info->copy_count] = j;
243       ++info->copy_count;
244     }
245     else if (onechan[j]) {
246       info->one[info->one_count] = j;
247       ++info->one_count;
248     }
249     else {
250       info->zero[info->zero_count] = j;
251       ++info->zero_count;
252     }
253   }
254
255 #if 0
256   {
257     for (i = 0; i < info->copy_count; ++i) {
258       printf("From %d to %d\n", info->from[i], info->to[i]);
259     }
260     for (i = 0; i < info->one_count; ++i) {
261       printf("One %d\n", info->one[i]);
262     }
263     for (i = 0; i < info->zero_count; ++i) {
264       printf("Zero %d\n", info->zero[i]);
265     }
266     fflush(stdout);
267   }
268 #endif
269
270   return 1;
271 }
272
273 /*
274 =item convert_via_copy(im, src, chan_copy_info)
275
276 Perform a convert that only requires channel copies.
277
278 =cut
279 */
280
281 static i_img *
282 convert_via_copy(i_img *im, i_img *src, struct chan_copy *info) {
283 #code src->bits <= i_8_bits
284   IM_COLOR *in_line = mymalloc(sizeof(IM_COLOR) * src->xsize);
285   IM_COLOR *out_line = mymalloc(sizeof(IM_COLOR) * src->xsize);
286   i_img_dim x, y;
287   int i;
288   IM_COLOR *inp, *outp;
289
290   for (y = 0; y < src->ysize; ++y) {
291     IM_GLIN(src, 0, src->xsize, y, in_line);
292
293     inp = in_line;
294     outp = out_line;
295     for (x = 0; x < src->xsize; ++x) {
296       for (i = 0; i < info->copy_count; ++i) {
297         outp->channel[info->to[i]] = inp->channel[info->from[i]];
298       }
299       for (i = 0; i < info->one_count; ++i) {
300         outp->channel[info->one[i]] = IM_SAMPLE_MAX;
301       }
302       for (i = 0; i < info->zero_count; ++i) {
303         outp->channel[info->zero[i]] = 0;
304       }
305       ++inp;
306       ++outp;
307     }
308     
309     IM_PLIN(im, 0, src->xsize, y, out_line);
310   }
311   
312   myfree(in_line);
313   myfree(out_line);
314 #/code
315       
316   return im;
317 }
318
319 /*
320 =back
321
322 =head1 SEE ALSO
323
324 Imager(3)
325
326 =head1 AUTHOR
327
328 Tony Cook <tony@develop-help.com>
329
330 =cut
331 */