X-Git-Url: http://git.asbjorn.biz/?a=blobdiff_plain;f=lib%2Fpython%2Fgfx.c;h=cbb4eb091eee64c528bdcded667209a6e4262341;hb=b641c574ebe37ed07e588d4577d853d74e999c99;hp=001ac21a3ab8993279486df44af767e640ef452a;hpb=0e0f1a451e3bbcbe3cc1f49273bc03ab8dd22a38;p=swftools.git diff --git a/lib/python/gfx.c b/lib/python/gfx.c index 001ac21..cbb4eb0 100644 --- a/lib/python/gfx.c +++ b/lib/python/gfx.c @@ -23,10 +23,16 @@ #include #include #undef HAVE_STAT +#include "../../config.h" +#include "../gfxtools.h" #include "../devices/swf.h" #include "../devices/render.h" +#include "../devices/ocr.h" #include "../devices/rescale.h" #include "../devices/text.h" +#ifdef USE_OPENGL +#include "../devices/opengl.h" +#endif #include "../pdf/pdf.h" #include "../readers/swf.h" #include "../readers/image.h" @@ -70,7 +76,7 @@ static char* strf(char*format, ...) va_end(arglist); return strdup(buf); } -#define PY_ERROR(s,args...) (PyErr_SetString(PyExc_Exception, strf(s, ## args)),NULL) +#define PY_ERROR(s,args...) (PyErr_SetString(PyExc_Exception, strf(s, ## args)),(PyObject*)NULL) #define PY_NONE Py_BuildValue("s", 0) //--------------------------------------------------------------------- @@ -124,6 +130,183 @@ static PyObject* output_startpage(PyObject* _self, PyObject* args, PyObject* kwa self->output_device->startpage(self->output_device, width, height); return PY_NONE; } + +/* as the definition of the python image type comes from another module (not + included here, reproduce the necessary structure and extract the image + without using the type definition */ +typedef struct { + PyObject_HEAD + gfximage_t*image; + PyObject* strrepr; +} ImageObject; +static gfximage_t*toImage(PyObject*_bitmap) +{ + if(!_bitmap || !_bitmap->ob_type->tp_name || strcmp(_bitmap->ob_type->tp_name, "Image")) { + PY_ERROR("Second argument to fillbitmap must be an image"); + return 0; + } + ImageObject*bitmap = (ImageObject*)_bitmap; + return bitmap->image; +} + +static gfxline_t*toLine(PyObject*_line) +{ + int t; + int num = PyList_Size(_line); + gfxline_t first; + first.next = 0; + gfxline_t*last=&first; + for(t=0;tnext = l; + last = l; + if(type[0]=='m') { + l->type = gfx_moveTo; + if(size!=3) + return PY_ERROR("need 2 values for move"); + l->x = PyFloat_AsDouble(PyTuple_GetItem(p, 1)); + l->y = PyFloat_AsDouble(PyTuple_GetItem(p, 2)); + } else if(type[0]=='l') { + l->type = gfx_lineTo; + if(size!=3) + return PY_ERROR("need 2 values for line"); + l->x = PyFloat_AsDouble(PyTuple_GetItem(p, 1)); + l->y = PyFloat_AsDouble(PyTuple_GetItem(p, 2)); + } else if(type[0]=='s') { + l->type = gfx_splineTo; + if(size!=5) + return PY_ERROR("need 4 values for spline"); + l->x = PyFloat_AsDouble(PyTuple_GetItem(p, 1)); + l->y = PyFloat_AsDouble(PyTuple_GetItem(p, 2)); + l->sx = PyFloat_AsDouble(PyTuple_GetItem(p, 3)); + l->sy = PyFloat_AsDouble(PyTuple_GetItem(p, 4)); + } else { + return PY_ERROR("Unknown line code '%s'", type); + } + } + return first.next; +} + +PyDoc_STRVAR(output_fillbitmap_doc, \ +"fillbitmap()\n\n" +"fill a polygon with a bitmap pattern\n" +); +static PyObject* output_fillbitmap(PyObject* _self, PyObject* args, PyObject* kwargs) +{ + OutputObject* self = (OutputObject*)_self; + PyObject*_line=0; + PyObject*_bitmap=0; + static char *kwlist[] = {"line", "bitmap", NULL}; + + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O!O", kwlist, &PyList_Type, &_line, &_bitmap)) + return NULL; + + gfximage_t*image = toImage(_bitmap); + if(!image) + return PY_ERROR("invalid image"); + + gfxline_t*line = toLine(_line); + if(!line) + return 0; + + /* TODO */ + gfxmatrix_t m; + memset(&m, 0, sizeof(gfxmatrix_t)); + m.m00 = m.m11 = 1.0; + + self->output_device->fillbitmap(self->output_device, line, image, &m, 0); + gfxline_free(line); + return PY_NONE; +} + +PyDoc_STRVAR(output_fill_doc, \ +"fill()\n\n" +"fill a polygon with a color\n" +); +static PyObject* output_fill(PyObject* _self, PyObject* args, PyObject* kwargs) +{ + OutputObject* self = (OutputObject*)_self; + PyObject*_line=0; + PyObject*_bitmap=0; + static char *kwlist[] = {"line", "color", NULL}; + + PyObject* color=0; + + int a=255,r=0,g=0,b=0; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O!O", kwlist, &PyList_Type, &_line, &color)) + return NULL; + + if(!PyArg_ParseTuple(color, "iiii:color", &a, &r, &g, &b)) { + return NULL; + } + + gfxcolor_t c; + c.r = r; c.g = g; c.b = b; c.a = a; + + gfxline_t*line = toLine(_line); + if(!line) + return 0; + + /* TODO */ + gfxmatrix_t m; + memset(&m, 0, sizeof(gfxmatrix_t)); + m.m00 = m.m11 = 1.0; + + self->output_device->fill(self->output_device, line, &c); + gfxline_free(line); + return PY_NONE; +} + +PyDoc_STRVAR(output_stroke_doc, \ +"stroke()\n\n" +"stroke a polygon with a color\n" +); +static PyObject* output_stroke(PyObject* _self, PyObject* args, PyObject* kwargs) +{ + OutputObject* self = (OutputObject*)_self; + PyObject*_line=0; + PyObject*_bitmap=0; + static char *kwlist[] = {"line", "width", "color", NULL}; + + PyObject* color=0; + + int a=255,r=0,g=0,b=0; + float width = 1.0; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O!fO", kwlist, &PyList_Type, &_line, &width, &color)) + return NULL; + + if(!PyArg_ParseTuple(color, "iiii:color", &a, &r, &g, &b)) { + return NULL; + } + + gfxcolor_t c; + c.r = r; c.g = g; c.b = b; c.a = a; + + gfxline_t*line = toLine(_line); + if(!line) + return 0; + + self->output_device->stroke(self->output_device, line, width, &c, + /*TODO*/ gfx_capRound, gfx_joinRound, 0.0); + gfxline_free(line); + return PY_NONE; +} + PyDoc_STRVAR(output_endpage_doc, \ "endpage()\n\n" "Ends a page in the output device. This function should be called\n" @@ -165,11 +348,32 @@ static PyObject* f_createSWF(PyObject* parent, PyObject* args, PyObject* kwargs) return NULL; OutputObject*self = PyObject_New(OutputObject, &OutputClass); - self->output_device = malloc(sizeof(gfxdevice_t)); + self->output_device = (gfxdevice_t*)malloc(sizeof(gfxdevice_t)); gfxdevice_swf_init(self->output_device); return (PyObject*)self; } +PyDoc_STRVAR(f_createOCR_doc, \ +"OCR()\n\n" +"Creates a device which processes documents using OCR (optical\n" +"character recognition).\n" +"This is handy for e.g. extracting fulltext from PDF documents\n" +"which have broken fonts, and where hence the \"PlainText\"\n" +"device doesn't work.\n" +); +static PyObject* f_createOCR(PyObject* parent, PyObject* args, PyObject* kwargs) +{ + static char *kwlist[] = {NULL}; + if (args && !PyArg_ParseTupleAndKeywords(args, kwargs, "", kwlist)) + return NULL; + OutputObject*self = PyObject_New(OutputObject, &OutputClass); + + self->output_device = (gfxdevice_t*)malloc(sizeof(gfxdevice_t)); + gfxdevice_ocr_init(self->output_device); + return (PyObject*)self; +} + + PyDoc_STRVAR(f_createImageList_doc, \ "ImageList()\n\n" "Creates a device which renders documents to bitmaps.\n" @@ -184,7 +388,7 @@ static PyObject* f_createImageList(PyObject* parent, PyObject* args, PyObject* k return NULL; OutputObject*self = PyObject_New(OutputObject, &OutputClass); - self->output_device = malloc(sizeof(gfxdevice_t)); + self->output_device = (gfxdevice_t*)malloc(sizeof(gfxdevice_t)); gfxdevice_render_init(self->output_device); return (PyObject*)self; } @@ -202,17 +406,37 @@ static PyObject* f_createPlainText(PyObject* parent, PyObject* args, PyObject* k return NULL; OutputObject*self = PyObject_New(OutputObject, &OutputClass); - self->output_device = malloc(sizeof(gfxdevice_t)); + self->output_device = (gfxdevice_t*)malloc(sizeof(gfxdevice_t)); gfxdevice_text_init(self->output_device); return (PyObject*)self; } -static PyObject*callback_python(char*function, gfxdevice_t*dev, const char*format, ...) +#ifdef USE_OPENGL +PyDoc_STRVAR(f_createOpenGL_doc, \ +"OpenGL()\n\n" +"Creates a device which renders everything to OpenGL.\n" +"Can be used for desktop display and debugging.\n" +"This device is not available on all systems.\n" +); +static PyObject* f_createOpenGL(PyObject* parent, PyObject* args, PyObject* kwargs) { - OutputObject*self = (OutputObject*)dev->internal; + static char *kwlist[] = {NULL}; + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "", kwlist)) + return NULL; + OutputObject*self = PyObject_New(OutputObject, &OutputClass); + self->output_device = (gfxdevice_t*)malloc(sizeof(gfxdevice_t)); + gfxdevice_opengl_init(self->output_device); + return (PyObject*)self; +} +#endif + +static char callback_python(char*function, gfxdevice_t*dev, const char*format, ...) +{ + OutputObject*self = (OutputObject*)dev->internal; + if(!PyObject_HasAttrString(self->pyobj, function)) - return PY_NONE; + return 0; va_list ap; va_start(ap, format); @@ -227,14 +451,17 @@ static PyObject*callback_python(char*function, gfxdevice_t*dev, const char*forma } else if(p=='i') { int i = va_arg(ap, int); PyTuple_SetItem(tuple, pos, PyInt_FromLong(i)); + } else if(p=='d') { + int i = va_arg(ap, double); + PyTuple_SetItem(tuple, pos, PyFloat_FromDouble(i)); } else if(p=='c') { void* ptr = va_arg(ap, void*); gfxcolor_t*col = (gfxcolor_t*)ptr; PyObject*colobj = PyTuple_New(4); - PyTuple_SetItem(colobj, 0, PyInt_FromLong(col->r)); - PyTuple_SetItem(colobj, 1, PyInt_FromLong(col->g)); - PyTuple_SetItem(colobj, 2, PyInt_FromLong(col->b)); - PyTuple_SetItem(colobj, 3, PyInt_FromLong(col->a)); + PyTuple_SetItem(colobj, 0, PyInt_FromLong(col->a)); + PyTuple_SetItem(colobj, 1, PyInt_FromLong(col->r)); + PyTuple_SetItem(colobj, 2, PyInt_FromLong(col->g)); + PyTuple_SetItem(colobj, 3, PyInt_FromLong(col->b)); PyTuple_SetItem(tuple, pos, colobj); } else if(p=='l') { void* ptr = va_arg(ap, void*); @@ -287,10 +514,10 @@ static PyObject*callback_python(char*function, gfxdevice_t*dev, const char*forma if(!result) { PyErr_Print(); PyErr_Clear(); - return 0; + return 1; } else { Py_DECREF(result); - return 0; + return 1; } } @@ -327,7 +554,7 @@ static void my_stroke(gfxdevice_t*dev, gfxline_t*line, gfxcoord_t width, gfxcolo joint = "round"; else if(joint_style == gfx_joinBevel) joint = "bevel"; - callback_python("stroke", dev, "licssi", line, width, color, cap, joint, miterLimit); + callback_python("stroke", dev, "ldcssi", line, width, color, cap, joint, miterLimit); } static void my_fill(gfxdevice_t*dev, gfxline_t*line, gfxcolor_t*color) { @@ -345,9 +572,19 @@ static void my_addfont(gfxdevice_t*dev, gfxfont_t*font) { callback_python("addfont", dev, "f", font); } -static void my_drawchar(gfxdevice_t*dev, gfxfont_t*font, int glyph, gfxcolor_t*color, gfxmatrix_t*matrix) +static void my_drawchar(gfxdevice_t*dev, gfxfont_t*font, int glyphnr, gfxcolor_t*color, gfxmatrix_t*matrix) { - callback_python("drawchar", dev, "ficm", font, glyph, color, matrix); + if(!callback_python("drawchar", dev, "ficm", font, glyphnr, color, matrix)) + { + if(!font) + return; + gfxglyph_t*glyph = &font->glyphs[glyphnr]; + gfxline_t*line2 = gfxline_clone(glyph->line); + gfxline_transform(line2, matrix); + my_fill(dev, line2, color); + gfxline_free(line2); + return; + } } static void my_drawlink(gfxdevice_t*dev, gfxline_t*line, const char*action) { @@ -391,7 +628,8 @@ static PyObject* f_createPassThrough(PyObject* parent, PyObject* args, PyObject* OutputObject*self = PyObject_New(OutputObject, &OutputClass); self->pyobj = obj; - self->output_device = malloc(sizeof(gfxdevice_t)); + Py_INCREF(obj); + self->output_device = (gfxdevice_t*)malloc(sizeof(gfxdevice_t)); memset(self->output_device, 0, sizeof(gfxdevice_t)); self->output_device->name = strdup("passthrough"); @@ -418,6 +656,9 @@ static PyMethodDef output_methods[] = /* Output functions */ {"save", (PyCFunction)output_save, METH_KEYWORDS, output_save_doc}, {"startpage", (PyCFunction)output_startpage, METH_KEYWORDS, output_startpage_doc}, + {"fill", (PyCFunction)output_fill, METH_KEYWORDS, output_fill_doc}, + {"fillbitmap", (PyCFunction)output_fillbitmap, METH_KEYWORDS, output_fillbitmap_doc}, + {"stroke", (PyCFunction)output_stroke, METH_KEYWORDS, output_stroke_doc}, {"endpage", (PyCFunction)output_endpage, METH_KEYWORDS, output_endpage_doc}, {"setparameter", (PyCFunction)output_setparameter, METH_KEYWORDS, output_setparameter_doc}, {0,0,0,0} @@ -543,7 +784,7 @@ static PyObject* page_asImage(PyObject* _self, PyObject* args, PyObject* kwargs) gfxresult_t*result = dev2.finish(&dev2); gfximage_t*img = (gfximage_t*)result->get(result,"page0"); int l = img->width*img->height; - unsigned char*data = malloc(img->width*img->height*3); + unsigned char*data = (unsigned char*)malloc(img->width*img->height*3); int s,t; for(t=0,s=0;tdata[t].r; @@ -683,16 +924,22 @@ static PyObject* doc_setparameter(PyObject* _self, PyObject* args, PyObject* kwa PyDoc_STRVAR(f_open_doc, "open(type, filename) -> object\n\n" -"Open a PDF file. The type argument always has to be \"pdf\"\n" -"It returns a doc object which can be used to process the pdf\n" -"contents. E.g.\n" +"Open a PDF, SWF or image file. The type argument should be \"pdf\",\n" +"\"swf\" or \"image\" accordingly. It returns a doc object which can be\n" +"used to process the file contents.\n" +"E.g.\n" " doc = open(\"pdf\", \"document.pdf\")\n" -"If the file is not a PDF file or is encrypted without\n" +" doc = open(\"swf\", \"flashfile.swf\")\n" +" doc = open(\"image\", \"image.png\")\n" +"If the file could not be loaded, or is a encrypted PDF file without\n" "a proper password specified, an exception is being raised.\n" "If the filename argument contains a '|' char, everything behind\n" "the '|' is treated as password used for opening the file.\n" "E.g.\n" " doc = open(\"pdf\", \"document.pdf|mysecretpassword\")\n" +".\n" +"Notice that for image files, the only supported file formats right now\n" +"are jpeg and png.\n" ); static PyObject* f_open(PyObject* parent, PyObject* args, PyObject* kwargs) { @@ -720,6 +967,8 @@ static PyObject* f_open(PyObject* parent, PyObject* args, PyObject* kwargs) type = "image"; if(strchr("pP", filename[l-3]) && strchr("nN", filename[l-2]) && strchr("gG", filename[l-1])) type = "image"; + if(strchr("sS", filename[l-3]) && strchr("wW", filename[l-2]) && strchr("fF", filename[l-1])) + type = "swf"; } else if(filename[l-5]=='.') { type = "image"; } @@ -728,9 +977,9 @@ static PyObject* f_open(PyObject* parent, PyObject* args, PyObject* kwargs) if(!strcmp(type,"pdf")) self->doc = pdfdriver->open(pdfdriver,filename); - else if(!strcmp(type, "image")) + else if(!strcmp(type, "image") || !strcmp(type, "img")) self->doc = imagedriver->open(imagedriver, filename); - else if(!strcmp(type, "swf")) + else if(!strcmp(type, "swf") || !strcmp(type, "SWF")) self->doc = swfdriver->open(imagedriver, filename); else return PY_ERROR("Unknown type %s", type); @@ -832,7 +1081,8 @@ PyDoc_STRVAR(doc_doc, "A Doc object is used for storing a document (like a PDF).\n" "doc.pages contains the number of pages in the document,\n" "and doc.filename the name of the file the document was\n" -"created (loaded) from\n" +"created (loaded) from. If the document was created from\n" +"an image file, the number of pages is always 1\n" ); static PyTypeObject DocClass = { @@ -934,15 +1184,18 @@ static PyMethodDef pdf2swf_methods[] = {"open", (PyCFunction)f_open, METH_KEYWORDS, f_open_doc}, {"addfont", (PyCFunction)f_addfont, METH_KEYWORDS, f_addfont_doc}, {"addfontdir", (PyCFunction)f_addfontdir, METH_KEYWORDS, f_addfontdir_doc}, - {"setoption", (PyCFunction)f_setparameter, METH_KEYWORDS, f_setparameter_doc}, // for backwards-compatibility {"setparameter", (PyCFunction)f_setparameter, METH_KEYWORDS, f_setparameter_doc}, {"verbose", (PyCFunction)f_verbose, METH_KEYWORDS, f_verbose_doc}, /* devices */ {"SWF", (PyCFunction)f_createSWF, METH_KEYWORDS, f_createSWF_doc}, + {"OCR", (PyCFunction)f_createOCR, METH_KEYWORDS, f_createOCR_doc}, {"ImageList", (PyCFunction)f_createImageList, METH_KEYWORDS, f_createImageList_doc}, {"PlainText", (PyCFunction)f_createPlainText, METH_KEYWORDS, f_createPlainText_doc}, {"PassThrough", (PyCFunction)f_createPassThrough, METH_KEYWORDS, f_createPassThrough_doc}, +#ifdef USE_OPENGL + {"OpenGL", (PyCFunction)f_createOpenGL, METH_KEYWORDS, f_createOpenGL_doc}, +#endif /* sentinel */ {0, 0, 0, 0} @@ -955,7 +1208,7 @@ PyDoc_STRVAR(gfx_doc, \ "The latter functionality is similar to what is offered by swftools'\n" "(http://www.swftools.org) pdf2swf utility, however more powerful-\n" "You can also create individual SWF files from single pages of the PDF\n" -"or combine more than one page into a bigger PDF.\n" +"or mix pages from different PDF files.\n" ); void initgfx(void)