MATRIX matrix_getMatrix(PyObject*self)
{
mylog(" %08x(%d) matrix_getMatrix", self, self->ob_refcnt);
PY_ASSERT_TYPE(self,&MatrixClass);
MatrixObject*matrix = (MatrixObject*)self;
return matrix->matrix;
}
static mp_obj_t py_image_draw_keypoints(mp_obj_t image_obj, mp_obj_t kpts_obj)
{
image_t *image = NULL;
py_kp_obj_t *kpts=NULL;
/* get pointer */
image = py_image_cobj(image_obj);
kpts = (py_kp_obj_t*)kpts_obj;
/* sanity checks */
PY_ASSERT_TRUE_MSG(image->bpp == 1,
"This function is only supported on GRAYSCALE images");
PY_ASSERT_TYPE(kpts_obj, &py_kp_type);
color_t cl = {.r=0xFF, .g=0xFF, .b=0xFF};
for (int i=0; i<kpts->size; i++) {
kp_t *kp = &kpts->kpts[i];
float co = arm_cos_f32(kp->angle);
float si = arm_sin_f32(kp->angle);
imlib_draw_line(image, kp->x, kp->y, kp->x+(co*10), kp->y+(si*10));
imlib_draw_circle(image, kp->x, kp->y, 4, &cl);
}
return mp_const_none;
}
static mp_obj_t py_image_find_blobs(mp_obj_t image_obj)
{
/* C stuff */
array_t *blobs;
struct image *image;
mp_obj_t blob_obj[6];
/* MP List */
mp_obj_t objects_list = mp_const_none;
/* get image pointer */
image = py_image_cobj(image_obj);
/* run color dector */
blobs = imlib_count_blobs(image);
/* Create empty Python list */
objects_list = mp_obj_new_list(0, NULL);
if (array_length(blobs)) {
for (int j=0; j<array_length(blobs); j++) {
blob_t *r = array_at(blobs, j);
blob_obj[0] = mp_obj_new_int(r->x);
blob_obj[1] = mp_obj_new_int(r->y);
blob_obj[2] = mp_obj_new_int(r->w);
blob_obj[3] = mp_obj_new_int(r->h);
blob_obj[4] = mp_obj_new_int(r->c);
blob_obj[5] = mp_obj_new_int(r->id);
mp_obj_list_append(objects_list, mp_obj_new_tuple(6, blob_obj));
}
}
array_free(blobs);
return objects_list;
}
//----------------------------------------------------------------------------
static int swf_setattr(PyObject * self, char* a, PyObject * o)
{
SWFObject*swf = (SWFObject*)self;
if(!strcmp(a, "fps")) {
double fps;
if (!PyArg_Parse(o, "d", &fps))
goto err;
swf->swf.frameRate = (int)(fps*0x100);
mylog(" %08x(%d) swf_setattr %s = %f\n", (int)self, self->ob_refcnt, a, fps);
return 0;
} else if(!strcmp(a, "version")) {
int version;
if (!PyArg_Parse(o, "i", &version))
goto err;
swf->swf.fileVersion = version;
mylog(" %08x(%d) swf_setattr %s = %d\n", (int)self, self->ob_refcnt, a, version);
return 0;
} else if(!strcmp(a, "name")) {
char*filename;
if (!PyArg_Parse(o, "s", &filename))
goto err;
if(swf->filename) {
free(swf->filename);swf->filename=0;
}
swf->filename = strdup(filename);
mylog(" %08x(%d) swf_setattr %s = %s\n", (int)self, self->ob_refcnt, a, filename);
return 0;
} else if(!strcmp(a, "bbox")) {
PyObject *obbox = o;
if (!PY_CHECK_TYPE(obbox, &BBoxClass)) {
obbox = f_BBox(0, o, 0);
if(!obbox)
return 1;
}
SRECT bbox = bbox_getSRECT(obbox);
swf->swf.movieSize = bbox;
mylog(" %08x(%d) swf_setattr %s = (%d,%d,%d,%d)\n", (int)self, self->ob_refcnt, a, bbox.xmin,bbox.ymin,bbox.xmax,bbox.ymax);
return 0;
} else if(!strcmp(a, "tags")) {
PyObject* taglist;
taglist = o;
PY_ASSERT_TYPE(taglist,&TagListClass);
Py_DECREF(swf->taglist);
swf->taglist = taglist;
Py_INCREF(swf->taglist);
mylog(" %08x(%d) swf_setattr %s = %08x\n", (int)self, self->ob_refcnt, a, swf->taglist);
return 0;
}
err:
mylog(" %08x(%d) swf_setattr %s = ? (%08x)\n", (int)self, self->ob_refcnt, a, o);
return 1;
}
static PyObject* matrix_getattr(PyObject * self, char* a)
{
PY_ASSERT_TYPE(self,&MatrixClass);
MatrixObject*matrix = (MatrixObject*)self;
if(!strcmp(a, "entries")) {
return Py_BuildValue("(ffffff)",
matrix->matrix.sx/65536.0,
matrix->matrix.r0/65536.0,
matrix->matrix.r1/65536.0,
matrix->matrix.sy/65536.0,
matrix->matrix.tx/20.0,
matrix->matrix.ty/20.0
);
}
return NULL;
}
// select helper functions
static void set_fds(int *nfds, mp_obj_t *fdlist, uint fdlist_len, fd_set *fdset)
{
FD_ZERO(fdset);
/* add sockets to fd set*/
for (int i=0; i<fdlist_len; i++) {
socket_t *s = fdlist[i];
/* check arg type*/
PY_ASSERT_TYPE(s, &socket_type);
/* add to fd set */
FD_SET(s->fd, fdset);
if (s->fd > (*nfds)) {
*nfds = s->fd;
}
}
}
void *py_image_cobj(mp_obj_t image)
{
PY_ASSERT_TYPE(image, &py_image_type);
return &((py_image_obj_t *)image)->_cobj;
}
void *py_cascade_cobj(mp_obj_t cascade)
{
PY_ASSERT_TYPE(cascade, &py_cascade_type);
return &((py_cascade_obj_t *)cascade)->_cobj;
}
void *py_file_cobj(mp_obj_t file)
{
PY_ASSERT_TYPE(file, &py_file_type);
return &((py_file_obj_t *)file)->fp;
}
static int matrix_setattr(PyObject * self, char* a, PyObject* o)
{
PY_ASSERT_TYPE(self,&MatrixClass);
return 0;
}
