Pillow

1
/*
2
 * The Python Imaging Library
3
 * $Id$
4
 *
5
 * various special effects and image generators
6
 *
7
 * history:
8
 * 1997-05-21 fl   Just for fun
9
 * 1997-06-05 fl   Added mandelbrot generator
10
 * 2003-05-24 fl   Added perlin_turbulence generator (in progress)
11
 *
12
 * Copyright (c) 1997-2003 by Fredrik Lundh.
13
 * Copyright (c) 1997 by Secret Labs AB.
14
 *
15
 * See the README file for information on usage and redistribution.
16
 */
17

18
#include "Imaging.h"
19

20
#include <math.h>
21

22
Imaging
23
ImagingEffectMandelbrot(int xsize, int ysize, double extent[4], int quality) {
24
    /* Generate a Mandelbrot set covering the given extent */
25

26
    Imaging im;
27
    int x, y, k;
28
    double width, height;
29
    double x1, y1, xi2, yi2, cr, ci, radius;
30
    double dr, di;
31

32
    /* Check arguments */
33
    width = extent[2] - extent[0];
34
    height = extent[3] - extent[1];
35
    if (width < 0.0 || height < 0.0 || quality < 2) {
36
        return (Imaging)ImagingError_ValueError(NULL);
37
    }
38

39
    im = ImagingNewDirty("L", xsize, ysize);
40
    if (!im) {
41
        return NULL;
42
    }
43

44
    dr = width / (xsize - 1);
45
    di = height / (ysize - 1);
46

47
    radius = 100.0;
48

49
    for (y = 0; y < ysize; y++) {
50
        UINT8 *buf = im->image8[y];
51
        for (x = 0; x < xsize; x++) {
52
            x1 = y1 = xi2 = yi2 = 0.0;
53
            cr = x * dr + extent[0];
54
            ci = y * di + extent[1];
55
            for (k = 1;; k++) {
56
                y1 = 2 * x1 * y1 + ci;
57
                x1 = xi2 - yi2 + cr;
58
                xi2 = x1 * x1;
59
                yi2 = y1 * y1;
60
                if ((xi2 + yi2) > radius) {
61
                    buf[x] = k * 255 / quality;
62
                    break;
63
                }
64
                if (k > quality) {
65
                    buf[x] = 0;
66
                    break;
67
                }
68
            }
69
        }
70
    }
71
    return im;
72
}
73

74
Imaging
75
ImagingEffectNoise(int xsize, int ysize, float sigma) {
76
    /* Generate Gaussian noise centered around 128 */
77

78
    Imaging imOut;
79
    int x, y;
80
    int nextok;
81
    double this, next;
82

83
    imOut = ImagingNewDirty("L", xsize, ysize);
84
    if (!imOut) {
85
        return NULL;
86
    }
87

88
    next = 0.0;
89
    nextok = 0;
90

91
    for (y = 0; y < imOut->ysize; y++) {
92
        UINT8 *out = imOut->image8[y];
93
        for (x = 0; x < imOut->xsize; x++) {
94
            if (nextok) {
95
                this = next;
96
                nextok = 0;
97
            } else {
98
                /* after numerical recipes */
99
                double v1, v2, radius, factor;
100
                do {
101
                    v1 = rand() * (2.0 / RAND_MAX) - 1.0;
102
                    v2 = rand() * (2.0 / RAND_MAX) - 1.0;
103
                    radius = v1 * v1 + v2 * v2;
104
                } while (radius >= 1.0);
105
                factor = sqrt(-2.0 * log(radius) / radius);
106
                this = factor * v1;
107
                next = factor * v2;
108
            }
109
            out[x] = CLIP8(128 + sigma * this);
110
        }
111
    }
112

113
    return imOut;
114
}
115

116
Imaging
117
ImagingEffectSpread(Imaging imIn, int distance) {
118
    /* Randomly spread pixels in an image */
119

120
    Imaging imOut;
121
    int x, y;
122

123
    imOut = ImagingNewDirty(imIn->mode, imIn->xsize, imIn->ysize);
124

125
    if (!imOut) {
126
        return NULL;
127
    }
128

129
#define SPREAD(type, image)                                                       \
130
    if (distance == 0) {                                                          \
131
        for (y = 0; y < imOut->ysize; y++) {                                      \
132
            for (x = 0; x < imOut->xsize; x++) {                                  \
133
                imOut->image[y][x] = imIn->image[y][x];                           \
134
            }                                                                     \
135
        }                                                                         \
136
    } else {                                                                      \
137
        for (y = 0; y < imOut->ysize; y++) {                                      \
138
            for (x = 0; x < imOut->xsize; x++) {                                  \
139
                int xx = x + (rand() % distance) - distance / 2;                  \
140
                int yy = y + (rand() % distance) - distance / 2;                  \
141
                if (xx >= 0 && xx < imIn->xsize && yy >= 0 && yy < imIn->ysize) { \
142
                    imOut->image[yy][xx] = imIn->image[y][x];                     \
143
                    imOut->image[y][x] = imIn->image[yy][xx];                     \
144
                } else {                                                          \
145
                    imOut->image[y][x] = imIn->image[y][x];                       \
146
                }                                                                 \
147
            }                                                                     \
148
        }                                                                         \
149
    }
150

151
    if (imIn->image8) {
152
        SPREAD(UINT8, image8);
153
    } else {
154
        SPREAD(INT32, image32);
155
    }
156

157
    ImagingCopyPalette(imOut, imIn);
158

159
    return imOut;
160
}
161