pcf.c

   1 #include <Python.h>
   2 #include <math.h>
   3
   4 static PyObject* py_combine(PyObject* self, PyObject* args)
   5 {
   6         const unsigned char *im_bg;
   7         const unsigned char *im_fg;
   8         int size;
   9
  10         int i;
  11         long int sum;
  12         int area;
  13
  14         if (!PyArg_ParseTuple(args, "s#s#", &im_bg, &size, &im_fg, &size)) return NULL;
  15
  16         sum = 0;
  17         area = 0;
  18         for (i=0; i < size; i++) {
  19                 if (im_fg[i]){
  20                         sum += im_bg[i];
  21                         area++;
  22                 }
  23         }
  24
  25         return Py_BuildValue("d", ((double) sum) / area);
  26 }
  27
  28 static PyObject* py_hough(PyObject* self, PyObject* args)
  29 {
  30         const unsigned char *image;
  31         int x;
  32         int y;
  33         int size;
  34         double init_angle;
  35         double dt;
  36
  37         int i;
  38         int j;
  39         int a;
  40
  41         double distance;
  42         int column;
  43         int minimum;
  44         int maximum;
  45
  46         int *matrix;
  47         unsigned char *n_image;
  48         PyObject *result;
  49
  50         if (!PyArg_ParseTuple(args, "(ii)s#dd", &x, &y, &image, &size, &init_angle, &dt)) return NULL;
  51
  52
  53         matrix = (int*) malloc(size * sizeof(int));
  54         for (i=0; i < x * y; i++) {
  55                 matrix[i] = 0;
  56         }
  57
  58
  59
  60         for (i=0; i < x; i++) {
  61                 for (j=0; j < y; j++) {
  62                         if (image[j * x + i]){
  63                                 for (a=0; a < y; a++){
  64                                         distance = (((i - x / 2) * sin((dt * a) + init_angle)) +
  65                                                         ((j - y / 2) * -cos((dt * a) + init_angle)) +
  66                                                         x / 2);
  67                                         column = (int) round(distance);
  68                                         if ((0 <= column) && (column < x)){
  69                                                 matrix[a * x + column]++;
  70                                         }
  71                                 }
  72                         }
  73                 }
  74         }
  75
  76
  77
  78
  79         n_image = (char*) malloc(size * sizeof(char));
  80         minimum = matrix[0];
  81         maximum = matrix[0];
  82         for (i=1; i < x * y; i++){
  83                 if (matrix[i] < minimum) minimum = matrix[i];
  84                 if (matrix[i] > maximum) maximum = matrix[i];
  85         }
  86         maximum = maximum - minimum + 1;
  87         for (i=0; i < x * y; i++){
  88                 n_image[i] = (char) ((((float) (matrix[i] - minimum)) / maximum) * 256);
  89         }
  90
  91         free(matrix);
  92
  93         result = Py_BuildValue("s#", n_image, size);
  94         free(n_image);
  95         return result;
  96 }
  97
  98 static PyObject* py_edge(PyObject* self, PyObject* args)
  99 {
 100         const unsigned char *image;
 101         int x;
 102         int y;
 103         int size;
 104
 105         int i;
 106         int j;
 107         int sum;
 108
 109         unsigned char *n_image;
 110         PyObject *result;
 111
 112         if (!PyArg_ParseTuple(args, "(ii)s#", &x, &y, &image, &size)) return NULL;
 113
 114         n_image = (char*) malloc(size);
 115         for (i=0; i < 2 * x; i++) {
 116                 n_image[i] = 0;
 117                 n_image[(y - 2) * x + i] = 0;
 118         }
 119         for (i=0; i < y; i++) {
 120                 n_image[x * i] = 0;
 121                 n_image[x * i + 1] = 0;
 122                 n_image[x * i + x - 2] = 0;
 123                 n_image[x * i + x - 1] = 0;
 124         }
 125
 126
 127
 128         for (i=2; i < x - 2; i++) {
 129                 for (j=2; j < y - 2; j++) {
 130                         sum = image[x * j + i - 2] + image[x * j + i - 1] + image[x * j + i + 1] + image[x * j + i + 2] +
 131                                 image[x * (j - 2) + i - 2] + image[x * (j - 2) + i - 1] + image[x * (j - 2) + i] +
 132                                 image[x * (j - 2) + i + 1] + image[x * (j - 2) + i + 2] +
 133                                 image[x * (j - 1) + i - 2] + image[x * (j - 1) + i - 1] + image[x * (j - 1) + i] +
 134                                 image[x * (j - 1) + i + 1] + image[x * (j - 1) + i + 2] +
 135                                 image[x * (j + 2) + i - 2] + image[x * (j + 2) + i - 1] + image[x * (j + 2) + i] +
 136                                 image[x * (j + 2) + i + 1] + image[x * (j + 2) + i + 2] +
 137                                 image[x * (j + 1) + i - 2] + image[x * (j + 1) + i - 1] + image[x * (j + 1) + i] +
 138                                 image[x * (j + 1) + i + 1] + image[x * (j + 1) + i + 2]
 139                                 - (24 * image[x * j + i]);
 140                         if (sum < 0) sum = 0;
 141                         if (sum > 255) sum = 255;
 142                         n_image[x * j + i] = sum;
 143                 }
 144         }
 145
 146
 147
 148         result = Py_BuildValue("s#", n_image, size);
 149         free(n_image);
 150         return result;
 151 }
 152
 153
 154 static PyMethodDef myModule_methods[] = {
 155         {"combine", py_combine, METH_VARARGS},
 156         {"edge", py_edge, METH_VARARGS},
 157         {"hough", py_hough, METH_VARARGS},
 158         {NULL, NULL}
 159 };
 160
 161 void initpcf()
 162 {
 163                 (void) Py_InitModule("pcf", myModule_methods);
 164 }