← Back to branch summary

~and471/inkscape/ocal-dialog-improvements

« back to all changes in this revision

Viewing changes to src/display/pixblock-transform.cpp

  • Committer: Andrew
  • Date: 2011-12-27 21:04:47 UTC
  • mfrom: (10092.1.704 inkscape)
  • Revision ID: at.higginson@gmail.com-20111227210447-7nngd0yuw0reb8kq
merged with trunk so I can build again...

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/display/pixblock-transform.cpp
1
 
#define __NR_PIXBLOCK_SCALER_CPP__
2
 
 
3
 
/*
4
 
 * Functions for blitting pixblocks using matrix transformation
5
 
 *
6
 
 * Author:
7
 
 *   Niko Kiirala <niko@kiirala.com>
8
 
 *
9
 
 * Copyright (C) 2006,2009 Niko Kiirala
10
 
 *
11
 
 * Released under GNU GPL, read the file 'COPYING' for more information
12
 
 */
13
 
 
14
 
#include <glib.h>
15
 
#include <cmath>
16
 
#if defined (SOLARIS) && (SOLARIS == 8)
17
 
#include "round.h"
18
 
using Inkscape::round;
19
 
#endif 
20
 
using std::floor;
21
 
 
22
 
#include "display/nr-filter-utils.h"
23
 
 
24
 
#include "libnr/nr-blit.h"
25
 
#include "libnr/nr-pixblock.h"
26
 
#include <2geom/affine.h>
27
 
 
28
 
namespace NR {
29
 
 
30
 
struct RGBA {
31
 
    double r, g, b, a;
32
 
};
33
 
struct RGBAi {
34
 
    int r, g, b, a;
35
 
};
36
 
 
37
 
/**
38
 
 * Sanity check function for indexing pixblocks.
39
 
 * Catches reading and writing outside the pixblock area.
40
 
 * When enabled, decreases filter rendering speed massively.
41
 
 */
42
 
inline void _check_index(NRPixBlock const * const pb, int const location, int const line)
43
 
{
44
 
    if(false) {
45
 
        int max_loc = pb->rs * (pb->area.y1 - pb->area.y0);
46
 
        if (location < 0 || (location + 4) > max_loc)
47
 
            g_warning("Location %d out of bounds (0 ... %d) at line %d", location, max_loc, line);
48
 
    }
49
 
}
50
 
 
51
 
void transform_nearest(NRPixBlock *to, NRPixBlock *from, Geom::Affine const &trans)
52
 
{
53
 
    if (NR_PIXBLOCK_BPP(from) != 4 || NR_PIXBLOCK_BPP(to) != 4) {
54
 
        g_warning("A non-32-bpp image passed to transform_nearest: scaling aborted.");
55
 
        return;
56
 
    }
57
 
 
58
 
    bool free_from_on_exit = false;
59
 
    if (from->mode != to->mode){
60
 
        NRPixBlock *o_from = from;
61
 
        from = new NRPixBlock;
62
 
        nr_pixblock_setup_fast(from, to->mode, o_from->area.x0, o_from->area.y0, o_from->area.x1, o_from->area.y1, false);
63
 
        nr_blit_pixblock_pixblock(from, o_from);
64
 
        free_from_on_exit = true;
65
 
    }
66
 
 
67
 
    // Precalculate sizes of source and destination pixblocks
68
 
    int from_width = from->area.x1 - from->area.x0;
69
 
    int from_height = from->area.y1 - from->area.y0;
70
 
    int to_width = to->area.x1 - to->area.x0;
71
 
    int to_height = to->area.y1 - to->area.y0;
72
 
 
73
 
    Geom::Affine itrans = trans.inverse();
74
 
 
75
 
    // Loop through every pixel of destination image, a line at a time
76
 
    for (int to_y = 0 ; to_y < to_height ; to_y++) {
77
 
        for (int to_x = 0 ; to_x < to_width ; to_x++) {
78
 
            RGBAi result = {0,0,0,0};
79
 
 
80
 
            int from_x = (int)floor(itrans[0] * (to_x + 0.5 + to->area.x0)
81
 
                                    + itrans[2] * (to_y + 0.5 + to->area.y0)
82
 
                                    + itrans[4]);
83
 
            from_x -= from->area.x0;
84
 
            int from_y = (int)floor(itrans[1] * (to_x + 0.5 + to->area.x0)
85
 
                                    + itrans[3] * (to_y + 0.5 + to->area.y0)
86
 
                                    + itrans[5]);
87
 
            from_y -= from->area.y0;
88
 
 
89
 
            if (from_x >= 0 && from_x < from_width
90
 
                && from_y >= 0 && from_y < from_height) {
91
 
                _check_index(from, from_y * from->rs + from_x * 4, __LINE__);
92
 
                result.r = NR_PIXBLOCK_PX(from)[from_y * from->rs + from_x * 4];
93
 
                result.g = NR_PIXBLOCK_PX(from)[from_y * from->rs + from_x * 4 + 1];
94
 
                result.b = NR_PIXBLOCK_PX(from)[from_y * from->rs + from_x * 4 + 2];
95
 
                result.a = NR_PIXBLOCK_PX(from)[from_y * from->rs + from_x * 4 + 3];
96
 
            }
97
 
 
98
 
            _check_index(to, to_y * to->rs + to_x * 4, __LINE__);
99
 
            NR_PIXBLOCK_PX(to)[to_y * to->rs + to_x * 4] = result.r;
100
 
            NR_PIXBLOCK_PX(to)[to_y * to->rs + to_x * 4 + 1] = result.g;
101
 
            NR_PIXBLOCK_PX(to)[to_y * to->rs + to_x * 4 + 2] = result.b;
102
 
            NR_PIXBLOCK_PX(to)[to_y * to->rs + to_x * 4 + 3] = result.a;
103
 
        }
104
 
    }
105
 
    if (free_from_on_exit) {
106
 
        nr_pixblock_release(from);
107
 
        delete from;
108
 
    }
109
 
}
110
 
 
111
 
/** Calculates cubically interpolated value of the four given pixel values.
112
 
 * The pixel values should be from four adjacent pixels in source image or
113
 
 * four adjacent interpolated values. len should be the x- or y-coordinate
114
 
 * (depending on interpolation direction) of the center of the target pixel
115
 
 * in source image coordinates.
116
 
 */
117
 
__attribute__ ((const))
118
 
inline static double sample(double const a, double const b,
119
 
                            double const c, double const d,
120
 
                            double const len)
121
 
{
122
 
    double lena = 1.5 + (len - round(len));
123
 
    double lenb = 0.5 + (len - round(len));
124
 
    double lenc = 0.5 - (len - round(len));
125
 
    double lend = 1.5 - (len - round(len));
126
 
    double const f = -0.5; // corresponds to cubic Hermite spline
127
 
    double sum = 0;
128
 
    sum += ((((f * lena) - 5.0 * f) * lena + 8.0 * f) * lena - 4 * f) * a;
129
 
    sum += (((f + 2.0) * lenb - (f + 3.0)) * lenb * lenb + 1.0) * b;
130
 
    sum += (((f + 2.0) * lenc - (f + 3.0)) * lenc * lenc + 1.0) * c;
131
 
    sum += ((((f * lend) - 5.0 * f) * lend + 8.0 * f) * lend - 4 * f) * d;
132
 
 
133
 
    return sum;
134
 
}
135
 
 
136
 
void transform_bicubic(NRPixBlock *to, NRPixBlock *from, Geom::Affine const &trans)
137
 
{
138
 
    if (NR_PIXBLOCK_BPP(from) != 4 || NR_PIXBLOCK_BPP(to) != 4) {
139
 
        g_warning("A non-32-bpp image passed to transform_bicubic: scaling aborted.");
140
 
        return;
141
 
    }
142
 
 
143
 
    bool free_from_on_exit = false;
144
 
    if (from->mode != to->mode){
145
 
        NRPixBlock *o_from = from;
146
 
        from = new NRPixBlock;
147
 
        nr_pixblock_setup_fast(from, to->mode, o_from->area.x0, o_from->area.y0, o_from->area.x1, o_from->area.y1, false);
148
 
        nr_blit_pixblock_pixblock(from, o_from);
149
 
        free_from_on_exit = true;
150
 
    }
151
 
 
152
 
    if (from->mode != NR_PIXBLOCK_MODE_R8G8B8A8P) {
153
 
        // TODO: Fix this... (The problem is that for interpolation non-premultiplied colors should be premultiplied...)
154
 
        g_warning("transform_bicubic does not properly support non-premultiplied images");
155
 
    }
156
 
    
157
 
    // Precalculate sizes of source and destination pixblocks
158
 
    int from_width = from->area.x1 - from->area.x0;
159
 
    int from_height = from->area.y1 - from->area.y0;
160
 
    int to_width = to->area.x1 - to->area.x0;
161
 
    int to_height = to->area.y1 - to->area.y0;
162
 
 
163
 
    Geom::Affine itrans = trans.inverse();
164
 
 
165
 
    // Loop through every pixel of destination image, a line at a time
166
 
    for (int to_y = 0 ; to_y < to_height ; to_y++) {
167
 
        for (int to_x = 0 ; to_x < to_width ; to_x++) {
168
 
            double from_x = itrans[0] * (to_x + 0.5 + to->area.x0)
169
 
                + itrans[2] * (to_y + 0.5 + to->area.y0)
170
 
                + itrans[4] - from->area.x0;
171
 
            double from_y = itrans[1] * (to_x + 0.5 + to->area.x0)
172
 
                + itrans[3] * (to_y + 0.5 + to->area.y0)
173
 
                + itrans[5] - from->area.y0;
174
 
 
175
 
            if (from_x < 0 || from_x >= from_width ||
176
 
                from_y < 0 || from_y >= from_height) {
177
 
                continue;
178
 
            }
179
 
 
180
 
            RGBA line[4];
181
 
 
182
 
            int from_line[4];
183
 
            for (int i = 0 ; i < 4 ; i++) {
184
 
                int fy_line = (int)round(from_y) + i - 2;
185
 
                if (fy_line >= 0) {
186
 
                    if (fy_line < from_height) {
187
 
                        from_line[i] = fy_line * from->rs;
188
 
                    } else {
189
 
                        from_line[i] = (from_height - 1) * from->rs;
190
 
                    }
191
 
                } else {
192
 
                    from_line[i] = 0;
193
 
                }                
194
 
            }
195
 
 
196
 
            for (int i = 0 ; i < 4 ; i++) {
197
 
                int k = (int)round(from_x) + i - 2;
198
 
                if (k < 0) k = 0;
199
 
                if (k >= from_width) k = from_width - 1;
200
 
                k *= 4;
201
 
                _check_index(from, from_line[0] + k, __LINE__);
202
 
                _check_index(from, from_line[1] + k, __LINE__);
203
 
                _check_index(from, from_line[2] + k, __LINE__);
204
 
                _check_index(from, from_line[3] + k, __LINE__);
205
 
                line[i].r = sample(NR_PIXBLOCK_PX(from)[from_line[0] + k],
206
 
                                   NR_PIXBLOCK_PX(from)[from_line[1] + k],
207
 
                                   NR_PIXBLOCK_PX(from)[from_line[2] + k],
208
 
                                   NR_PIXBLOCK_PX(from)[from_line[3] + k],
209
 
                                   from_y);
210
 
                line[i].g = sample(NR_PIXBLOCK_PX(from)[from_line[0] + k + 1],
211
 
                                   NR_PIXBLOCK_PX(from)[from_line[1] + k + 1],
212
 
                                   NR_PIXBLOCK_PX(from)[from_line[2] + k + 1],
213
 
                                   NR_PIXBLOCK_PX(from)[from_line[3] + k + 1],
214
 
                                   from_y);
215
 
                line[i].b = sample(NR_PIXBLOCK_PX(from)[from_line[0] + k + 2],
216
 
                                   NR_PIXBLOCK_PX(from)[from_line[1] + k + 2],
217
 
                                   NR_PIXBLOCK_PX(from)[from_line[2] + k + 2],
218
 
                                   NR_PIXBLOCK_PX(from)[from_line[3] + k + 2],
219
 
                                   from_y);
220
 
                line[i].a = sample(NR_PIXBLOCK_PX(from)[from_line[0] + k + 3],
221
 
                                   NR_PIXBLOCK_PX(from)[from_line[1] + k + 3],
222
 
                                   NR_PIXBLOCK_PX(from)[from_line[2] + k + 3],
223
 
                                   NR_PIXBLOCK_PX(from)[from_line[3] + k + 3],
224
 
                                   from_y);
225
 
            }
226
 
            RGBA result;
227
 
            result.r = round(sample(line[0].r, line[1].r, line[2].r, line[3].r,
228
 
                                    from_x));
229
 
            result.g = round(sample(line[0].g, line[1].g, line[2].g, line[3].g,
230
 
                                    from_x));
231
 
            result.b = round(sample(line[0].b, line[1].b, line[2].b, line[3].b,
232
 
                                    from_x));
233
 
            result.a = round(sample(line[0].a, line[1].a, line[2].a, line[3].a,
234
 
                                    from_x));
235
 
 
236
 
            using Inkscape::Filters::clamp;
237
 
            using Inkscape::Filters::clamp_alpha;
238
 
            _check_index(to, to_y * to->rs + to_x * 4, __LINE__);
239
 
            if (to->mode == NR_PIXBLOCK_MODE_R8G8B8A8P) {
240
 
                /* Make sure, none of the RGB channels exceeds 100% intensity
241
 
                 * in premultiplied output */
242
 
                int const alpha = clamp((int)result.a);
243
 
                NR_PIXBLOCK_PX(to)[to_y * to->rs + to_x * 4] = 
244
 
                    clamp_alpha((int)result.r, alpha);
245
 
                NR_PIXBLOCK_PX(to)[to_y * to->rs + to_x * 4 + 1] = 
246
 
                    clamp_alpha((int)result.g, alpha);
247
 
                NR_PIXBLOCK_PX(to)[to_y * to->rs + to_x * 4 + 2] = 
248
 
                    clamp_alpha((int)result.b, alpha);
249
 
                NR_PIXBLOCK_PX(to)[to_y * to->rs + to_x * 4 + 3] = alpha;
250
 
            } else {
251
 
                /* Clamp the output to unsigned char range */
252
 
                NR_PIXBLOCK_PX(to)[to_y * to->rs + to_x * 4]
253
 
                    = clamp((int)result.r);
254
 
                NR_PIXBLOCK_PX(to)[to_y * to->rs + to_x * 4 + 1]
255
 
                    = clamp((int)result.g);
256
 
                NR_PIXBLOCK_PX(to)[to_y * to->rs + to_x * 4 + 2]
257
 
                    = clamp((int)result.b);
258
 
                NR_PIXBLOCK_PX(to)[to_y * to->rs + to_x * 4 + 3]
259
 
                    = clamp((int)result.a);
260
 
            }
261
 
        }
262
 
    }
263
 
    if (free_from_on_exit) {
264
 
        nr_pixblock_release(from);
265
 
        delete from;
266
 
    }
267
 
}
268
 
 
269
 
} /* namespace NR */
270
 
/*
271
 
  Local Variables:
272
 
  mode:c++
273
 
  c-file-style:"stroustrup"
274
 
  c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
275
 
  indent-tabs-mode:nil
276
 
  fill-column:99
277
 
  End:
278
 
*/
279
 
// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:fileencoding=utf-8:textwidth=99 :