source: vendor/python/2.5/Modules/imageop.c@ 3609

Last change on this file since 3609 was 3225, checked in by bird, 19 years ago

Python 2.5
File size: 16.9 KB
Line 
1
2/* imageopmodule - Various operations on pictures */
3
4#ifdef sun
5#define signed
6#endif
7
8#include "Python.h"
9
10#if SIZEOF_INT == 4
11typedef int Py_Int32;
12typedef unsigned int Py_UInt32;
13#else
14#if SIZEOF_LONG == 4
15typedef long Py_Int32;
16typedef unsigned long Py_UInt32;
17#else
18#error "No 4-byte integral type"
19#endif
20#endif
21
22#define CHARP(cp, xmax, x, y) ((char *)(cp+y*xmax+x))
23#define SHORTP(cp, xmax, x, y) ((short *)(cp+2*(y*xmax+x)))
24#define LONGP(cp, xmax, x, y) ((Py_Int32 *)(cp+4*(y*xmax+x)))
25
26static PyObject *ImageopError;
27static PyObject *ImageopDict;
28
29/* If this function returns true (the default if anything goes wrong), we're
30 behaving in a backward-compatible way with respect to how multi-byte pixels
31 are stored in the strings. The code in this module was originally written
32 for an SGI which is a big-endian system, and so the old code assumed that
33 4-byte integers hold the R, G, and B values in a particular order.
34 However, on little-endian systems the order is reversed, and so not
35 actually compatible with what gl.lrectwrite and imgfile expect.
36 (gl.lrectwrite and imgfile are also SGI-specific, however, it is
37 conceivable that the data handled here comes from or goes to an SGI or that
38 it is otherwise used in the expectation that the byte order in the strings
39 is as specified.)
40
41 The function returns the value of the module variable
42 "backward_compatible", or 1 if the variable does not exist or is not an
43 int.
44 */
45
46static int
47imageop_backward_compatible(void)
48{
49 static PyObject *bcos;
50 PyObject *bco;
51 long rc;
52
53 if (ImageopDict == NULL) /* "cannot happen" */
54 return 1;
55 if (bcos == NULL) {
56 /* cache string object for future use */
57 bcos = PyString_FromString("backward_compatible");
58 if (bcos == NULL)
59 return 1;
60 }
61 bco = PyDict_GetItem(ImageopDict, bcos);
62 if (bco == NULL)
63 return 1;
64 if (!PyInt_Check(bco))
65 return 1;
66 rc = PyInt_AsLong(bco);
67 if (PyErr_Occurred()) {
68 /* not an integer, or too large, or something */
69 PyErr_Clear();
70 rc = 1;
71 }
72 return rc != 0; /* convert to values 0, 1 */
73}
74
75static PyObject *
76imageop_crop(PyObject *self, PyObject *args)
77{
78 char *cp, *ncp;
79 short *nsp;
80 Py_Int32 *nlp;
81 int len, size, x, y, newx1, newx2, newy1, newy2;
82 int ix, iy, xstep, ystep;
83 PyObject *rv;
84
85 if ( !PyArg_ParseTuple(args, "s#iiiiiii", &cp, &len, &size, &x, &y,
86 &newx1, &newy1, &newx2, &newy2) )
87 return 0;
88
89 if ( size != 1 && size != 2 && size != 4 ) {
90 PyErr_SetString(ImageopError, "Size should be 1, 2 or 4");
91 return 0;
92 }
93 if ( len != size*x*y ) {
94 PyErr_SetString(ImageopError, "String has incorrect length");
95 return 0;
96 }
97 xstep = (newx1 < newx2)? 1 : -1;
98 ystep = (newy1 < newy2)? 1 : -1;
99
100 rv = PyString_FromStringAndSize(NULL,
101 (abs(newx2-newx1)+1)*(abs(newy2-newy1)+1)*size);
102 if ( rv == 0 )
103 return 0;
104 ncp = (char *)PyString_AsString(rv);
105 nsp = (short *)ncp;
106 nlp = (Py_Int32 *)ncp;
107 newy2 += ystep;
108 newx2 += xstep;
109 for( iy = newy1; iy != newy2; iy+=ystep ) {
110 for ( ix = newx1; ix != newx2; ix+=xstep ) {
111 if ( iy < 0 || iy >= y || ix < 0 || ix >= x ) {
112 if ( size == 1 )
113 *ncp++ = 0;
114 else
115 *nlp++ = 0;
116 } else {
117 if ( size == 1 )
118 *ncp++ = *CHARP(cp, x, ix, iy);
119 else if ( size == 2 )
120 *nsp++ = *SHORTP(cp, x, ix, iy);
121 else
122 *nlp++ = *LONGP(cp, x, ix, iy);
123 }
124 }
125 }
126 return rv;
127}
128
129static PyObject *
130imageop_scale(PyObject *self, PyObject *args)
131{
132 char *cp, *ncp;
133 short *nsp;
134 Py_Int32 *nlp;
135 int len, size, x, y, newx, newy;
136 int ix, iy;
137 int oix, oiy;
138 PyObject *rv;
139
140 if ( !PyArg_ParseTuple(args, "s#iiiii",
141 &cp, &len, &size, &x, &y, &newx, &newy) )
142 return 0;
143
144 if ( size != 1 && size != 2 && size != 4 ) {
145 PyErr_SetString(ImageopError, "Size should be 1, 2 or 4");
146 return 0;
147 }
148 if ( len != size*x*y ) {
149 PyErr_SetString(ImageopError, "String has incorrect length");
150 return 0;
151 }
152
153 rv = PyString_FromStringAndSize(NULL, newx*newy*size);
154 if ( rv == 0 )
155 return 0;
156 ncp = (char *)PyString_AsString(rv);
157 nsp = (short *)ncp;
158 nlp = (Py_Int32 *)ncp;
159 for( iy = 0; iy < newy; iy++ ) {
160 for ( ix = 0; ix < newx; ix++ ) {
161 oix = ix * x / newx;
162 oiy = iy * y / newy;
163 if ( size == 1 )
164 *ncp++ = *CHARP(cp, x, oix, oiy);
165 else if ( size == 2 )
166 *nsp++ = *SHORTP(cp, x, oix, oiy);
167 else
168 *nlp++ = *LONGP(cp, x, oix, oiy);
169 }
170 }
171 return rv;
172}
173
174/* Note: this routine can use a bit of optimizing */
175
176static PyObject *
177imageop_tovideo(PyObject *self, PyObject *args)
178{
179 int maxx, maxy, x, y, len;
180 int i;
181 unsigned char *cp, *ncp;
182 int width;
183 PyObject *rv;
184
185
186 if ( !PyArg_ParseTuple(args, "s#iii", &cp, &len, &width, &maxx, &maxy) )
187 return 0;
188
189 if ( width != 1 && width != 4 ) {
190 PyErr_SetString(ImageopError, "Size should be 1 or 4");
191 return 0;
192 }
193 if ( maxx*maxy*width != len ) {
194 PyErr_SetString(ImageopError, "String has incorrect length");
195 return 0;
196 }
197
198 rv = PyString_FromStringAndSize(NULL, len);
199 if ( rv == 0 )
200 return 0;
201 ncp = (unsigned char *)PyString_AsString(rv);
202
203 if ( width == 1 ) {
204 memcpy(ncp, cp, maxx); /* Copy first line */
205 ncp += maxx;
206 for (y=1; y<maxy; y++) { /* Interpolate other lines */
207 for(x=0; x<maxx; x++) {
208 i = y*maxx + x;
209 *ncp++ = ((int)cp[i] + (int)cp[i-maxx]) >> 1;
210 }
211 }
212 } else {
213 memcpy(ncp, cp, maxx*4); /* Copy first line */
214 ncp += maxx*4;
215 for (y=1; y<maxy; y++) { /* Interpolate other lines */
216 for(x=0; x<maxx; x++) {
217 i = (y*maxx + x)*4 + 1;
218 *ncp++ = 0; /* Skip alfa comp */
219 *ncp++ = ((int)cp[i] + (int)cp[i-4*maxx]) >> 1;
220 i++;
221 *ncp++ = ((int)cp[i] + (int)cp[i-4*maxx]) >> 1;
222 i++;
223 *ncp++ = ((int)cp[i] + (int)cp[i-4*maxx]) >> 1;
224 }
225 }
226 }
227 return rv;
228}
229
230static PyObject *
231imageop_grey2mono(PyObject *self, PyObject *args)
232{
233 int tres, x, y, len;
234 unsigned char *cp, *ncp;
235 unsigned char ovalue;
236 PyObject *rv;
237 int i, bit;
238
239
240 if ( !PyArg_ParseTuple(args, "s#iii", &cp, &len, &x, &y, &tres) )
241 return 0;
242
243 if ( x*y != len ) {
244 PyErr_SetString(ImageopError, "String has incorrect length");
245 return 0;
246 }
247
248 rv = PyString_FromStringAndSize(NULL, (len+7)/8);
249 if ( rv == 0 )
250 return 0;
251 ncp = (unsigned char *)PyString_AsString(rv);
252
253 bit = 0x80;
254 ovalue = 0;
255 for ( i=0; i < len; i++ ) {
256 if ( (int)cp[i] > tres )
257 ovalue |= bit;
258 bit >>= 1;
259 if ( bit == 0 ) {
260 *ncp++ = ovalue;
261 bit = 0x80;
262 ovalue = 0;
263 }
264 }
265 if ( bit != 0x80 )
266 *ncp++ = ovalue;
267 return rv;
268}
269
270static PyObject *
271imageop_grey2grey4(PyObject *self, PyObject *args)
272{
273 int x, y, len;
274 unsigned char *cp, *ncp;
275 unsigned char ovalue;
276 PyObject *rv;
277 int i;
278 int pos;
279
280
281 if ( !PyArg_ParseTuple(args, "s#ii", &cp, &len, &x, &y) )
282 return 0;
283
284 if ( x*y != len ) {
285 PyErr_SetString(ImageopError, "String has incorrect length");
286 return 0;
287 }
288
289 rv = PyString_FromStringAndSize(NULL, (len+1)/2);
290 if ( rv == 0 )
291 return 0;
292 ncp = (unsigned char *)PyString_AsString(rv);
293 pos = 0;
294 ovalue = 0;
295 for ( i=0; i < len; i++ ) {
296 ovalue |= ((int)cp[i] & 0xf0) >> pos;
297 pos += 4;
298 if ( pos == 8 ) {
299 *ncp++ = ovalue;
300 ovalue = 0;
301 pos = 0;
302 }
303 }
304 if ( pos != 0 )
305 *ncp++ = ovalue;
306 return rv;
307}
308
309static PyObject *
310imageop_grey2grey2(PyObject *self, PyObject *args)
311{
312 int x, y, len;
313 unsigned char *cp, *ncp;
314 unsigned char ovalue;
315 PyObject *rv;
316 int i;
317 int pos;
318
319
320 if ( !PyArg_ParseTuple(args, "s#ii", &cp, &len, &x, &y) )
321 return 0;
322
323 if ( x*y != len ) {
324 PyErr_SetString(ImageopError, "String has incorrect length");
325 return 0;
326 }
327
328 rv = PyString_FromStringAndSize(NULL, (len+3)/4);
329 if ( rv == 0 )
330 return 0;
331 ncp = (unsigned char *)PyString_AsString(rv);
332 pos = 0;
333 ovalue = 0;
334 for ( i=0; i < len; i++ ) {
335 ovalue |= ((int)cp[i] & 0xc0) >> pos;
336 pos += 2;
337 if ( pos == 8 ) {
338 *ncp++ = ovalue;
339 ovalue = 0;
340 pos = 0;
341 }
342 }
343 if ( pos != 0 )
344 *ncp++ = ovalue;
345 return rv;
346}
347
348static PyObject *
349imageop_dither2mono(PyObject *self, PyObject *args)
350{
351 int sum, x, y, len;
352 unsigned char *cp, *ncp;
353 unsigned char ovalue;
354 PyObject *rv;
355 int i, bit;
356
357
358 if ( !PyArg_ParseTuple(args, "s#ii", &cp, &len, &x, &y) )
359 return 0;
360
361 if ( x*y != len ) {
362 PyErr_SetString(ImageopError, "String has incorrect length");
363 return 0;
364 }
365
366 rv = PyString_FromStringAndSize(NULL, (len+7)/8);
367 if ( rv == 0 )
368 return 0;
369 ncp = (unsigned char *)PyString_AsString(rv);
370
371 bit = 0x80;
372 ovalue = 0;
373 sum = 0;
374 for ( i=0; i < len; i++ ) {
375 sum += cp[i];
376 if ( sum >= 256 ) {
377 sum -= 256;
378 ovalue |= bit;
379 }
380 bit >>= 1;
381 if ( bit == 0 ) {
382 *ncp++ = ovalue;
383 bit = 0x80;
384 ovalue = 0;
385 }
386 }
387 if ( bit != 0x80 )
388 *ncp++ = ovalue;
389 return rv;
390}
391
392static PyObject *
393imageop_dither2grey2(PyObject *self, PyObject *args)
394{
395 int x, y, len;
396 unsigned char *cp, *ncp;
397 unsigned char ovalue;
398 PyObject *rv;
399 int i;
400 int pos;
401 int sum = 0, nvalue;
402
403
404 if ( !PyArg_ParseTuple(args, "s#ii", &cp, &len, &x, &y) )
405 return 0;
406
407 if ( x*y != len ) {
408 PyErr_SetString(ImageopError, "String has incorrect length");
409 return 0;
410 }
411
412 rv = PyString_FromStringAndSize(NULL, (len+3)/4);
413 if ( rv == 0 )
414 return 0;
415 ncp = (unsigned char *)PyString_AsString(rv);
416 pos = 1;
417 ovalue = 0;
418 for ( i=0; i < len; i++ ) {
419 sum += cp[i];
420 nvalue = sum & 0x180;
421 sum -= nvalue;
422 ovalue |= nvalue >> pos;
423 pos += 2;
424 if ( pos == 9 ) {
425 *ncp++ = ovalue;
426 ovalue = 0;
427 pos = 1;
428 }
429 }
430 if ( pos != 0 )
431 *ncp++ = ovalue;
432 return rv;
433}
434
435static PyObject *
436imageop_mono2grey(PyObject *self, PyObject *args)
437{
438 int v0, v1, x, y, len, nlen;
439 unsigned char *cp, *ncp;
440 PyObject *rv;
441 int i, bit;
442
443 if ( !PyArg_ParseTuple(args, "s#iiii", &cp, &len, &x, &y, &v0, &v1) )
444 return 0;
445
446 nlen = x*y;
447 if ( (nlen+7)/8 != len ) {
448 PyErr_SetString(ImageopError, "String has incorrect length");
449 return 0;
450 }
451
452 rv = PyString_FromStringAndSize(NULL, nlen);
453 if ( rv == 0 )
454 return 0;
455 ncp = (unsigned char *)PyString_AsString(rv);
456
457 bit = 0x80;
458 for ( i=0; i < nlen; i++ ) {
459 if ( *cp & bit )
460 *ncp++ = v1;
461 else
462 *ncp++ = v0;
463 bit >>= 1;
464 if ( bit == 0 ) {
465 bit = 0x80;
466 cp++;
467 }
468 }
469 return rv;
470}
471
472static PyObject *
473imageop_grey22grey(PyObject *self, PyObject *args)
474{
475 int x, y, len, nlen;
476 unsigned char *cp, *ncp;
477 PyObject *rv;
478 int i, pos, value = 0, nvalue;
479
480 if ( !PyArg_ParseTuple(args, "s#ii", &cp, &len, &x, &y) )
481 return 0;
482
483 nlen = x*y;
484 if ( (nlen+3)/4 != len ) {
485 PyErr_SetString(ImageopError, "String has incorrect length");
486 return 0;
487 }
488
489 rv = PyString_FromStringAndSize(NULL, nlen);
490 if ( rv == 0 )
491 return 0;
492 ncp = (unsigned char *)PyString_AsString(rv);
493
494 pos = 0;
495 for ( i=0; i < nlen; i++ ) {
496 if ( pos == 0 ) {
497 value = *cp++;
498 pos = 8;
499 }
500 pos -= 2;
501 nvalue = (value >> pos) & 0x03;
502 *ncp++ = nvalue | (nvalue << 2) |
503 (nvalue << 4) | (nvalue << 6);
504 }
505 return rv;
506}
507
508static PyObject *
509imageop_grey42grey(PyObject *self, PyObject *args)
510{
511 int x, y, len, nlen;
512 unsigned char *cp, *ncp;
513 PyObject *rv;
514 int i, pos, value = 0, nvalue;
515
516 if ( !PyArg_ParseTuple(args, "s#ii", &cp, &len, &x, &y) )
517 return 0;
518
519 nlen = x*y;
520 if ( (nlen+1)/2 != len ) {
521 PyErr_SetString(ImageopError, "String has incorrect length");
522 return 0;
523 }
524
525 rv = PyString_FromStringAndSize(NULL, nlen);
526 if ( rv == 0 )
527 return 0;
528 ncp = (unsigned char *)PyString_AsString(rv);
529
530 pos = 0;
531 for ( i=0; i < nlen; i++ ) {
532 if ( pos == 0 ) {
533 value = *cp++;
534 pos = 8;
535 }
536 pos -= 4;
537 nvalue = (value >> pos) & 0x0f;
538 *ncp++ = nvalue | (nvalue << 4);
539 }
540 return rv;
541}
542
543static PyObject *
544imageop_rgb2rgb8(PyObject *self, PyObject *args)
545{
546 int x, y, len, nlen;
547 unsigned char *cp;
548 unsigned char *ncp;
549 PyObject *rv;
550 int i, r, g, b;
551 int backward_compatible = imageop_backward_compatible();
552
553 if ( !PyArg_ParseTuple(args, "s#ii", &cp, &len, &x, &y) )
554 return 0;
555
556 nlen = x*y;
557 if ( nlen*4 != len ) {
558 PyErr_SetString(ImageopError, "String has incorrect length");
559 return 0;
560 }
561
562 rv = PyString_FromStringAndSize(NULL, nlen);
563 if ( rv == 0 )
564 return 0;
565 ncp = (unsigned char *)PyString_AsString(rv);
566
567 for ( i=0; i < nlen; i++ ) {
568 /* Bits in source: aaaaaaaa BBbbbbbb GGGggggg RRRrrrrr */
569 if (backward_compatible) {
570 Py_UInt32 value = * (Py_UInt32 *) cp;
571 cp += 4;
572 r = (int) ((value & 0xff) / 255. * 7. + .5);
573 g = (int) (((value >> 8) & 0xff) / 255. * 7. + .5);
574 b = (int) (((value >> 16) & 0xff) / 255. * 3. + .5);
575 } else {
576 cp++; /* skip alpha channel */
577 b = (int) (*cp++ / 255. * 3. + .5);
578 g = (int) (*cp++ / 255. * 7. + .5);
579 r = (int) (*cp++ / 255. * 7. + .5);
580 }
581 *ncp++ = (unsigned char)((r<<5) | (b<<3) | g);
582 }
583 return rv;
584}
585
586static PyObject *
587imageop_rgb82rgb(PyObject *self, PyObject *args)
588{
589 int x, y, len, nlen;
590 unsigned char *cp;
591 unsigned char *ncp;
592 PyObject *rv;
593 int i, r, g, b;
594 unsigned char value;
595 int backward_compatible = imageop_backward_compatible();
596
597 if ( !PyArg_ParseTuple(args, "s#ii", &cp, &len, &x, &y) )
598 return 0;
599
600 nlen = x*y;
601 if ( nlen != len ) {
602 PyErr_SetString(ImageopError, "String has incorrect length");
603 return 0;
604 }
605
606 rv = PyString_FromStringAndSize(NULL, nlen*4);
607 if ( rv == 0 )
608 return 0;
609 ncp = (unsigned char *)PyString_AsString(rv);
610
611 for ( i=0; i < nlen; i++ ) {
612 /* Bits in source: RRRBBGGG
613 ** Red and Green are multiplied by 36.5, Blue by 85
614 */
615 value = *cp++;
616 r = (value >> 5) & 7;
617 g = (value ) & 7;
618 b = (value >> 3) & 3;
619 r = (r<<5) | (r<<3) | (r>>1);
620 g = (g<<5) | (g<<3) | (g>>1);
621 b = (b<<6) | (b<<4) | (b<<2) | b;
622 if (backward_compatible) {
623 Py_UInt32 nvalue = r | (g<<8) | (b<<16);
624 * (Py_UInt32 *) ncp = nvalue;
625 ncp += 4;
626 } else {
627 *ncp++ = 0;
628 *ncp++ = b;
629 *ncp++ = g;
630 *ncp++ = r;
631 }
632 }
633 return rv;
634}
635
636static PyObject *
637imageop_rgb2grey(PyObject *self, PyObject *args)
638{
639 int x, y, len, nlen;
640 unsigned char *cp;
641 unsigned char *ncp;
642 PyObject *rv;
643 int i, r, g, b;
644 int nvalue;
645 int backward_compatible = imageop_backward_compatible();
646
647 if ( !PyArg_ParseTuple(args, "s#ii", &cp, &len, &x, &y) )
648 return 0;
649
650 nlen = x*y;
651 if ( nlen*4 != len ) {
652 PyErr_SetString(ImageopError, "String has incorrect length");
653 return 0;
654 }
655
656 rv = PyString_FromStringAndSize(NULL, nlen);
657 if ( rv == 0 )
658 return 0;
659 ncp = (unsigned char *)PyString_AsString(rv);
660
661 for ( i=0; i < nlen; i++ ) {
662 if (backward_compatible) {
663 Py_UInt32 value = * (Py_UInt32 *) cp;
664 cp += 4;
665 r = (int) ((value & 0xff) / 255. * 7. + .5);
666 g = (int) (((value >> 8) & 0xff) / 255. * 7. + .5);
667 b = (int) (((value >> 16) & 0xff) / 255. * 3. + .5);
668 } else {
669 cp++; /* skip alpha channel */
670 b = *cp++;
671 g = *cp++;
672 r = *cp++;
673 }
674 nvalue = (int)(0.30*r + 0.59*g + 0.11*b);
675 if ( nvalue > 255 ) nvalue = 255;
676 *ncp++ = (unsigned char)nvalue;
677 }
678 return rv;
679}
680
681static PyObject *
682imageop_grey2rgb(PyObject *self, PyObject *args)
683{
684 int x, y, len, nlen;
685 unsigned char *cp;
686 unsigned char *ncp;
687 PyObject *rv;
688 int i;
689 unsigned char value;
690 int backward_compatible = imageop_backward_compatible();
691
692 if ( !PyArg_ParseTuple(args, "s#ii", &cp, &len, &x, &y) )
693 return 0;
694
695 nlen = x*y;
696 if ( nlen != len ) {
697 PyErr_SetString(ImageopError, "String has incorrect length");
698 return 0;
699 }
700
701 rv = PyString_FromStringAndSize(NULL, nlen*4);
702 if ( rv == 0 )
703 return 0;
704 ncp = (unsigned char *)PyString_AsString(rv);
705
706 for ( i=0; i < nlen; i++ ) {
707 value = *cp++;
708 if (backward_compatible) {
709 * (Py_UInt32 *) ncp = (Py_UInt32) value | ((Py_UInt32) value << 8 ) | ((Py_UInt32) value << 16);
710 ncp += 4;
711 } else {
712 *ncp++ = 0;
713 *ncp++ = value;
714 *ncp++ = value;
715 *ncp++ = value;
716 }
717 }
718 return rv;
719}
720
721/*
722static object *
723imageop_mul(object *self, object *args)
724{
725 char *cp, *ncp;
726 int len, size, x, y;
727 object *rv;
728 int i;
729
730 if ( !getargs(args, "(s#iii)", &cp, &len, &size, &x, &y) )
731 return 0;
732
733 if ( size != 1 && size != 4 ) {
734 err_setstr(ImageopError, "Size should be 1 or 4");
735 return 0;
736 }
737 if ( len != size*x*y ) {
738 err_setstr(ImageopError, "String has incorrect length");
739 return 0;
740 }
741
742 rv = newsizedstringobject(NULL, XXXX);
743 if ( rv == 0 )
744 return 0;
745 ncp = (char *)getstringvalue(rv);
746
747
748 for ( i=0; i < len; i += size ) {
749 }
750 return rv;
751}
752*/
753
754static PyMethodDef imageop_methods[] = {
755 { "crop", imageop_crop, METH_VARARGS },
756 { "scale", imageop_scale, METH_VARARGS },
757 { "grey2mono", imageop_grey2mono, METH_VARARGS },
758 { "grey2grey2", imageop_grey2grey2, METH_VARARGS },
759 { "grey2grey4", imageop_grey2grey4, METH_VARARGS },
760 { "dither2mono", imageop_dither2mono, METH_VARARGS },
761 { "dither2grey2", imageop_dither2grey2, METH_VARARGS },
762 { "mono2grey", imageop_mono2grey, METH_VARARGS },
763 { "grey22grey", imageop_grey22grey, METH_VARARGS },
764 { "grey42grey", imageop_grey42grey, METH_VARARGS },
765 { "tovideo", imageop_tovideo, METH_VARARGS },
766 { "rgb2rgb8", imageop_rgb2rgb8, METH_VARARGS },
767 { "rgb82rgb", imageop_rgb82rgb, METH_VARARGS },
768 { "rgb2grey", imageop_rgb2grey, METH_VARARGS },
769 { "grey2rgb", imageop_grey2rgb, METH_VARARGS },
770 { 0, 0 }
771};
772
773
774PyMODINIT_FUNC
775initimageop(void)
776{
777 PyObject *m;
778 m = Py_InitModule("imageop", imageop_methods);
779 if (m == NULL)
780 return;
781 ImageopDict = PyModule_GetDict(m);
782 ImageopError = PyErr_NewException("imageop.error", NULL, NULL);
783 if (ImageopError != NULL)
784 PyDict_SetItemString(ImageopDict, "error", ImageopError);
785}
Note: See TracBrowser for help on using the repository browser.