pcf.c

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