comparisons against $ExtUtils::MakeMaker::VERSION were warning when
[imager.git] / scale.c
1 #include "imager.h"
2
3 /*
4  * i_scale_mixing() is based on code contained in pnmscale.c, part of
5  * the netpbm distribution.  No code was copied from pnmscale but
6  * the algorthm was and for this I thank the netpbm crew.
7  *
8  * Tony
9  */
10
11 /* pnmscale.c - read a portable anymap and scale it
12 **
13 ** Copyright (C) 1989, 1991 by Jef Poskanzer.
14 **
15 ** Permission to use, copy, modify, and distribute this software and its
16 ** documentation for any purpose and without fee is hereby granted, provided
17 ** that the above copyright notice appear in all copies and that both that
18 ** copyright notice and this permission notice appear in supporting
19 ** documentation.  This software is provided "as is" without express or
20 ** implied warranty.
21 **
22 */
23
24
25 static void
26 zero_row(i_fcolor *row, int width, int channels);
27 static void
28 accum_output_row(i_fcolor *accum, double fraction, i_fcolor const *in,
29                  int width, int channels);
30 static void
31 horizontal_scale(i_fcolor *out, int out_width, 
32                  i_fcolor const *in, int in_width,
33                  int channels);
34
35 /*
36 =item i_scale_mixing
37
38 Returns a new image scaled to the given size.
39
40 Unlike i_scale_axis() this does a simple coverage of pixels from
41 source to target and doesn't resample.
42
43 Adapted from pnmscale.
44
45 =cut
46 */
47 i_img *
48 i_scale_mixing(i_img *src, int x_out, int y_out) {
49   i_img *result;
50   i_fcolor *in_row = NULL;
51   i_fcolor *xscale_row = NULL;
52   i_fcolor *accum_row = NULL;
53   int y;
54   int in_row_bytes, out_row_bytes;
55   double rowsleft, fracrowtofill;
56   int rowsread;
57   double y_scale;
58
59   mm_log((1, "i_scale_mixing(src %p, x_out %d, y_out %d)\n", 
60           src, x_out, y_out));
61
62   i_clear_error();
63
64   if (x_out <= 0) {
65     i_push_errorf(0, "output width %d invalid", x_out);
66     return NULL;
67   }
68   if (y_out <= 0) {
69     i_push_errorf(0, "output height %d invalid", y_out);
70     return NULL;
71   }
72
73   in_row_bytes = sizeof(i_fcolor) * src->xsize;
74   if (in_row_bytes / sizeof(i_fcolor) != src->xsize) {
75     i_push_error(0, "integer overflow allocating input row buffer");
76     return NULL;
77   }
78   out_row_bytes = sizeof(i_fcolor) * x_out;
79   if (out_row_bytes / sizeof(i_fcolor) != x_out) {
80     i_push_error(0, "integer overflow allocating output row buffer");
81     return NULL;
82   }
83
84   if (x_out == src->xsize && y_out == src->ysize) {
85     return i_copy(src);
86   }
87
88   y_scale = y_out / (double)src->ysize;
89
90   result = i_sametype_chans(src, x_out, y_out, src->channels);
91   if (!result)
92     return NULL;
93
94   in_row     = mymalloc(in_row_bytes);
95   accum_row  = mymalloc(in_row_bytes);
96   xscale_row = mymalloc(out_row_bytes);
97
98   rowsread = 0;
99   rowsleft = 0.0;
100   for (y = 0; y < y_out; ++y) {
101     if (y_out == src->ysize) {
102       i_glinf(src, 0, src->xsize, y, accum_row);
103     }
104     else {
105       fracrowtofill = 1.0;
106       zero_row(accum_row, src->xsize, src->channels);
107       while (fracrowtofill > 0) {
108         if (rowsleft <= 0) {
109           if (rowsread < src->ysize) {
110             i_glinf(src, 0, src->xsize, rowsread, in_row);
111             ++rowsread;
112           }
113           /* else just use the last row read */
114
115           rowsleft = y_scale;
116         }
117         if (rowsleft < fracrowtofill) {
118           accum_output_row(accum_row, rowsleft, in_row, src->xsize, 
119                            src->channels);
120           fracrowtofill -= rowsleft;
121           rowsleft = 0;
122         }
123         else {
124           accum_output_row(accum_row, fracrowtofill, in_row, src->xsize, 
125                            src->channels);
126           rowsleft -= fracrowtofill;
127           fracrowtofill = 0;
128         }
129       }
130       /* we've accumulated a vertically scaled row */
131       if (x_out == src->xsize) {
132         /* no need to scale */
133         i_plinf(result, 0, x_out, y, accum_row);
134       }
135       else {
136         horizontal_scale(xscale_row, x_out, accum_row, src->xsize, 
137                          src->channels);
138         i_plinf(result, 0, x_out, y, xscale_row);
139       }
140     }
141   }
142
143   myfree(in_row);
144   myfree(accum_row);
145   myfree(xscale_row);
146
147   return result;
148 }
149
150 static void
151 zero_row(i_fcolor *row, int width, int channels) {
152   int x;
153   int ch;
154
155   /* with IEEE floats we could just use memset() but that's not
156      safe in general under ANSI C */
157   for (x = 0; x < width; ++x) {
158     for (ch = 0; ch < channels; ++ch)
159       row[x].channel[ch] = 0.0;
160   }
161 }
162
163 static void
164 accum_output_row(i_fcolor *accum, double fraction, i_fcolor const *in,
165                  int width, int channels) {
166   int x, ch;
167
168   for (x = 0; x < width; ++x) {
169     for (ch = 0; ch < channels; ++ch) {
170       accum[x].channel[ch] += in[x].channel[ch] * fraction;
171     }
172   }
173 }
174
175 static void
176 horizontal_scale(i_fcolor *out, int out_width, 
177                  i_fcolor const *in, int in_width,
178                  int channels) {
179   double frac_col_to_fill, frac_col_left;
180   int in_x;
181   int out_x;
182   double x_scale = (double)out_width / in_width;
183   int ch;
184   double accum[MAXCHANNELS] = { 0 };
185   
186   frac_col_to_fill = 1.0;
187   out_x = 0;
188   for (in_x = 0; in_x < in_width; ++in_x) {
189     frac_col_left = x_scale;
190     while (frac_col_left >= frac_col_to_fill) {
191       for (ch = 0; ch < channels; ++ch)
192         accum[ch] += frac_col_to_fill * in[in_x].channel[ch];
193
194       for (ch = 0; ch < channels; ++ch) {
195         out[out_x].channel[ch] = accum[ch];
196         accum[ch] = 0;
197       }
198       frac_col_left -= frac_col_to_fill;
199       frac_col_to_fill = 1.0;
200       ++out_x;
201     }
202
203     if (frac_col_left > 0) {
204       for (ch = 0; ch < channels; ++ch) {
205         accum[ch] += frac_col_left * in[in_x].channel[ch];
206       }
207       frac_col_to_fill -= frac_col_left;
208     }
209   }
210
211   if (out_x < out_width-1 || out_x > out_width) {
212     i_fatal(3, "Internal error: out_x %d out of range (width %d)", out_x, out_width);
213   }
214   
215   if (out_x < out_width) {
216     for (ch = 0; ch < channels; ++ch) {
217       accum[ch] += frac_col_to_fill * in[in_width-1].channel[ch];
218       out[out_x].channel[ch] = accum[ch];
219     }
220   }
221 }