Py::Object pymur_index_environment::addFile(const Py::Tuple &rargs) { ArgChecker("addFile", rargs).param(STRING).oparam(STRING).check(); int docsseen = env.documentsSeen(); string fname = Py::String(rargs[0]).as_std_string(); if(rargs.length() == 1) { env.addFile(fname); } else { env.addFile(fname, Py::String(rargs[1]).as_std_string()); } if(env.documentsSeen() == docsseen) throw Py::RuntimeError("Problem reading file \"" + fname + "\""); return Py::None(); };
/* ------------ module methods ------------- */ Py::Object _backend_agg_module::new_renderer (const Py::Tuple &args, const Py::Dict &kws) { if (args.length() != 3 ) { throw Py::RuntimeError("Incorrect # of args to RendererAgg(width, height, dpi)."); } int debug; if ( kws.hasKey("debug") ) debug = Py::Int( kws["debug"] ); else debug=0; int width = Py::Int(args[0]); int height = Py::Int(args[1]); double dpi = Py::Float(args[2]); return Py::asObject(new RendererAgg(width, height, dpi, debug)); }
Py::Object pymur_index_environment::addString(const Py::Tuple &rargs) { ArgChecker("addString", rargs).param(STRING).param(STRING).oparam(DICT).check(); string docstring = Py::String(rargs[0]).as_std_string(); string fclass = Py::String(rargs[1]).as_std_string(); vector<indri::parse::MetadataPair> vmetadata; if(rargs.length() == 3) { Py::Dict mdp(rargs[2]); for(int i=0; i < mdp.length(); i++) { Py::String key(mdp.keys()[i]); Py::String value(mdp[key]); indri::parse::MetadataPair metadata; make_metadata_pair(metadata, key.as_std_string(), value.as_std_string()); vmetadata.push_back(metadata); } } int docid = (int) env.addString(docstring, fclass, vmetadata); return Py::Int(docid); };
Py::Object RendererAgg::draw_poly_collection(const Py::Tuple& args) { theRasterizer->reset_clipping(); _VERBOSE("RendererAgg::draw_poly_collection"); args.verify_length(9); Py::SeqBase<Py::Object> verts = args[0]; //todo: fix transformation check Transformation* transform = static_cast<Transformation*>(args[1].ptr()); transform->eval_scalars(); set_clip_from_bbox(args[2]); Py::SeqBase<Py::Object> facecolors = args[3]; Py::SeqBase<Py::Object> edgecolors = args[4]; Py::SeqBase<Py::Object> linewidths = args[5]; Py::SeqBase<Py::Object> antialiaseds = args[6]; Py::SeqBase<Py::Object> offsets; Transformation* transOffset = NULL; bool usingOffsets = args[7].ptr() != Py_None; if (usingOffsets) { offsets = args[7]; //todo: fix transformation check transOffset = static_cast<Transformation*>(args[8].ptr()); transOffset->eval_scalars(); } size_t Noffsets = offsets.length(); size_t Nverts = verts.length(); size_t Nface = facecolors.length(); size_t Nedge = edgecolors.length(); size_t Nlw = linewidths.length(); size_t Naa = antialiaseds.length(); size_t N = (Noffsets>Nverts) ? Noffsets : Nverts; std::pair<double, double> xyo, xy; Py::Tuple thisverts; for (size_t i=0; i<N; ++i) { thisverts = verts[i % Nverts]; if (usingOffsets) { Py::Tuple pos = Py::Tuple(offsets[i]); double xo = Py::Float(pos[0]); double yo = Py::Float(pos[1]); xyo = transOffset->operator()(xo, yo); } size_t Nverts = thisverts.length(); agg::path_storage path; Py::Tuple thisvert; // dump the verts to double arrays so we can do more efficient // look aheads and behinds when doing snapto pixels double xs[Nverts], ys[Nverts]; for (size_t j=0; j<Nverts; ++j) { thisvert = Py::Tuple(thisverts[j]); double x = Py::Float(thisvert[0]); double y = Py::Float(thisvert[1]); xy = transform->operator()(x, y); if (usingOffsets) { xy.first += xyo.first; xy.second += xyo.second; } xy.second = height - xy.second; xs[j] = xy.first; ys[j] = xy.second; } for (size_t j=0; j<Nverts; ++j) { double x = xs[j]; double y = ys[j]; if (j==0) { if (xs[j] == xs[Nverts-1]) x = (int)xs[j] + 0.5; if (ys[j] == ys[Nverts-1]) y = (int)ys[j] + 0.5; } else if (j==Nverts-1) { if (xs[j] == xs[0]) x = (int)xs[j] + 0.5; if (ys[j] == ys[0]) y = (int)ys[j] + 0.5; } if (j < Nverts-1) { if (xs[j] == xs[j+1]) x = (int)xs[j] + 0.5; if (ys[j] == ys[j+1]) y = (int)ys[j] + 0.5; } if (j>0) { if (xs[j] == xs[j-1]) x = (int)xs[j] + 0.5; if (ys[j] == ys[j-1]) y = (int)ys[j] + 0.5; } if (j==0) path.move_to(x,y); else path.line_to(x,y); } path.close_polygon(); int isaa = Py::Int(antialiaseds[i%Naa]); // get the facecolor and render Py::Tuple rgba = Py::Tuple(facecolors[ i%Nface]); double r = Py::Float(rgba[0]); double g = Py::Float(rgba[1]); double b = Py::Float(rgba[2]); double a = Py::Float(rgba[3]); if (a>0) { //only render if alpha>0 agg::rgba facecolor(r, g, b, a); theRasterizer->add_path(path); if (isaa) { rendererAA->color(facecolor); agg::render_scanlines(*theRasterizer, *slineP8, *rendererAA); } else { rendererBin->color(facecolor); agg::render_scanlines(*theRasterizer, *slineBin, *rendererBin); } } //renderer face // get the edgecolor and render rgba = Py::Tuple(edgecolors[ i%Nedge]); r = Py::Float(rgba[0]); g = Py::Float(rgba[1]); b = Py::Float(rgba[2]); a = Py::Float(rgba[3]); if (a>0) { //only render if alpha>0 agg::rgba edgecolor(r, g, b, a); agg::conv_stroke<agg::path_storage> stroke(path); //stroke.line_cap(cap); //stroke.line_join(join); double lw = points_to_pixels ( Py::Float( linewidths[i%Nlw] ) ); stroke.width(lw); theRasterizer->add_path(stroke); // render antialiased or not if ( isaa ) { rendererAA->color(edgecolor); agg::render_scanlines(*theRasterizer, *slineP8, *rendererAA); } else { rendererBin->color(edgecolor); agg::render_scanlines(*theRasterizer, *slineBin, *rendererBin); } } //rendered edge } // for every poly return Py::Object(); }
Py::Object _image_module::pcolor2(const Py::Tuple& args) { _VERBOSE("_image_module::pcolor2"); if (args.length() != 7) throw Py::TypeError("Incorrect number of arguments (6 expected)"); Py::Object xp = args[0]; Py::Object yp = args[1]; Py::Object dp = args[2]; int rows = Py::Int(args[3]); int cols = Py::Int(args[4]); Py::Tuple bounds = args[5]; Py::Object bgp = args[6]; if (bounds.length() !=4) throw Py::TypeError("Incorrect number of bounds (4 expected)"); double x_left = Py::Float(bounds[0]); double x_right = Py::Float(bounds[1]); double y_bot = Py::Float(bounds[2]); double y_top = Py::Float(bounds[3]); // Check we have something to output to if (rows == 0 || cols ==0) throw Py::ValueError("rows or cols is zero; there are no pixels"); // Get numpy arrays PyArrayObject *x = (PyArrayObject *) PyArray_ContiguousFromObject(xp.ptr(), PyArray_DOUBLE, 1, 1); if (x == NULL) throw Py::ValueError("x is of incorrect type (wanted 1D double)"); PyArrayObject *y = (PyArrayObject *) PyArray_ContiguousFromObject(yp.ptr(), PyArray_DOUBLE, 1, 1); if (y == NULL) { Py_XDECREF(x); throw Py::ValueError("y is of incorrect type (wanted 1D double)"); } PyArrayObject *d = (PyArrayObject *) PyArray_ContiguousFromObject(dp.ptr(), PyArray_UBYTE, 3, 3); if (d == NULL) { Py_XDECREF(x); Py_XDECREF(y); throw Py::ValueError("data is of incorrect type (wanted 3D uint8)"); } if (d->dimensions[2] != 4) { Py_XDECREF(x); Py_XDECREF(y); Py_XDECREF(d); throw Py::ValueError("data must be in RGBA format"); } // Check dimensions match int nx = x->dimensions[0]; int ny = y->dimensions[0]; if (nx != d->dimensions[1]+1 || ny != d->dimensions[0]+1) { Py_XDECREF(x); Py_XDECREF(y); Py_XDECREF(d); throw Py::ValueError("data and axis bin boundary dimensions are incompatible"); } PyArrayObject *bg = (PyArrayObject *) PyArray_ContiguousFromObject(bgp.ptr(), PyArray_UBYTE, 1, 1); if (bg == NULL) { Py_XDECREF(x); Py_XDECREF(y); Py_XDECREF(d); throw Py::ValueError("bg is of incorrect type (wanted 1D uint8)"); } if (bg->dimensions[0] != 4) { Py_XDECREF(x); Py_XDECREF(y); Py_XDECREF(d); Py_XDECREF(bg); throw Py::ValueError("bg must be in RGBA format"); } // Allocate memory for pointer arrays int * irows = reinterpret_cast<int*>(PyMem_Malloc(sizeof(int)*rows)); if (irows == NULL) { Py_XDECREF(x); Py_XDECREF(y); Py_XDECREF(d); Py_XDECREF(bg); throw Py::MemoryError("Cannot allocate memory for lookup table"); } int * jcols = reinterpret_cast<int*>(PyMem_Malloc(sizeof(int*)*cols)); if (jcols == NULL) { Py_XDECREF(x); Py_XDECREF(y); Py_XDECREF(d); Py_XDECREF(bg); PyMem_Free(irows); throw Py::MemoryError("Cannot allocate memory for lookup table"); } // Create output Image* imo = new Image; imo->rowsIn = rows; imo->rowsOut = rows; imo->colsIn = cols; imo->colsOut = cols; size_t NUMBYTES(rows * cols * 4); agg::int8u *buffer = new agg::int8u[NUMBYTES]; if (buffer == NULL) { Py_XDECREF(x); Py_XDECREF(y); Py_XDECREF(d); Py_XDECREF(bg); PyMem_Free(irows); PyMem_Free(jcols); throw Py::MemoryError("Could not allocate memory for image"); } // Calculate the pointer arrays to map input x to output x int i, j; double *x0 = reinterpret_cast<double*>(x->data); double *y0 = reinterpret_cast<double*>(y->data); double sx = cols/(x_right - x_left); double sy = rows/(y_top - y_bot); _bin_indices(jcols, cols, x0, nx, sx, x_left); _bin_indices(irows, rows, y0, ny, sy, y_bot); // Copy data to output buffer agg::int8u * position = buffer; unsigned char *start = reinterpret_cast<unsigned char*>(d->data); unsigned char *bgptr = reinterpret_cast<unsigned char*>(bg->data); int s0 = d->strides[0]; int s1 = d->strides[1]; for (i=0; i<rows; i++) { for (j=0; j<cols; j++) { if (irows[i] == -1 || jcols[j] == -1) { memcpy(position, bgptr, 4*sizeof(agg::int8u)); } else { memcpy(position, (start + s0*irows[i] + s1*jcols[j]), 4*sizeof(agg::int8u)); } position += 4; } } // Attach output buffer to output buffer imo->rbufOut = new agg::rendering_buffer; imo->bufferOut = buffer; imo->rbufOut->attach(imo->bufferOut, imo->colsOut, imo->rowsOut, imo->colsOut * imo->BPP); Py_XDECREF(x); Py_XDECREF(y); Py_XDECREF(d); Py_XDECREF(bg); PyMem_Free(irows); PyMem_Free(jcols); return Py::asObject(imo); }
Py::Object _image_module::pcolor(const Py::Tuple& args) { _VERBOSE("_image_module::pcolor"); if (args.length() != 6) throw Py::TypeError("Incorrect number of arguments (6 expected)"); Py::Object xp = args[0]; Py::Object yp = args[1]; Py::Object dp = args[2]; unsigned int rows = Py::Int(args[3]); unsigned int cols = Py::Int(args[4]); Py::Tuple bounds = args[5]; if (bounds.length() !=4) throw Py::TypeError("Incorrect number of bounds (4 expected)"); float x_min = Py::Float(bounds[0]); float x_max = Py::Float(bounds[1]); float y_min = Py::Float(bounds[2]); float y_max = Py::Float(bounds[3]); float width = x_max - x_min; float height = y_max - y_min; float dx = width / ((float) cols); float dy = height / ((float) rows); // Check we have something to output to if (rows == 0 || cols ==0) throw Py::ValueError("Cannot scale to zero size"); // Get numpy arrays PyArrayObject *x = (PyArrayObject *) PyArray_ContiguousFromObject(xp.ptr(), PyArray_FLOAT, 1, 1); if (x == NULL) throw Py::ValueError("x is of incorrect type (wanted 1D float)"); PyArrayObject *y = (PyArrayObject *) PyArray_ContiguousFromObject(yp.ptr(), PyArray_FLOAT, 1, 1); if (y == NULL) { Py_XDECREF(x); throw Py::ValueError("y is of incorrect type (wanted 1D float)"); } PyArrayObject *d = (PyArrayObject *) PyArray_ContiguousFromObject(dp.ptr(), PyArray_UBYTE, 3, 3); if (d == NULL) { Py_XDECREF(x); Py_XDECREF(y); throw Py::ValueError("data is of incorrect type (wanted 3D UInt8)"); } if (d->dimensions[2] != 4) { Py_XDECREF(x); Py_XDECREF(y); Py_XDECREF(d); throw Py::ValueError("data must be in RGBA format"); } // Check dimensions match int nx = x->dimensions[0]; int ny = y->dimensions[0]; if (nx != d->dimensions[1] || ny != d->dimensions[0]) { Py_XDECREF(x); Py_XDECREF(y); Py_XDECREF(d); throw Py::ValueError("data and axis dimensions do not match"); } // Allocate memory for pointer arrays unsigned int * rowstarts = reinterpret_cast<unsigned int*>(PyMem_Malloc(sizeof(unsigned int)*rows)); if (rowstarts == NULL) { Py_XDECREF(x); Py_XDECREF(y); Py_XDECREF(d); throw Py::MemoryError("Cannot allocate memory for lookup table"); } unsigned int * colstarts = reinterpret_cast<unsigned int*>(PyMem_Malloc(sizeof(unsigned int*)*cols)); if (colstarts == NULL) { Py_XDECREF(x); Py_XDECREF(y); Py_XDECREF(d); PyMem_Free(rowstarts); throw Py::MemoryError("Cannot allocate memory for lookup table"); } // Create output Image* imo = new Image; imo->rowsIn = rows; imo->colsIn = cols; imo->rowsOut = rows; imo->colsOut = cols; size_t NUMBYTES(rows * cols * 4); agg::int8u *buffer = new agg::int8u[NUMBYTES]; if (buffer == NULL) { Py_XDECREF(x); Py_XDECREF(y); Py_XDECREF(d); PyMem_Free(rowstarts); PyMem_Free(colstarts); throw Py::MemoryError("Could not allocate memory for image"); } // Calculate the pointer arrays to map input x to output x unsigned int i, j, j_last; unsigned int * colstart = colstarts; unsigned int * rowstart = rowstarts; float *xs1 = reinterpret_cast<float*>(x->data); float *ys1 = reinterpret_cast<float*>(y->data); float *xs2 = xs1+1; float *ys2 = ys1+1; float *xl = xs1 + nx - 1; float *yl = ys1 + ny - 1; float xo = x_min + dx/2.0; float yo = y_min + dy/2.0; float xm = 0.5*(*xs1 + *xs2); float ym = 0.5*(*ys1 + *ys2); // x/cols j = 0; j_last = j; for (i=0;i<cols;i++,xo+=dx,colstart++) { while(xs2 != xl && xo > xm) { xs1 = xs2; xs2 = xs1+1; xm = 0.5*(*xs1 + *xs2); j++; } *colstart = j - j_last; j_last = j; } // y/rows j = 0; j_last = j; for (i=0;i<rows;i++,yo+=dy,rowstart++) { while(ys2 != yl && yo > ym) { ys1 = ys2; ys2 = ys1+1; ym = 0.5*(*ys1 + *ys2); j++; } *rowstart = j - j_last; j_last = j; } // Copy data to output buffer unsigned char *start; unsigned char *inposition; size_t inrowsize(nx*4); size_t rowsize(cols*4); rowstart = rowstarts; agg::int8u * position = buffer; agg::int8u * oldposition = NULL; start = reinterpret_cast<unsigned char*>(d->data); for(i=0;i<rows;i++,rowstart++) { if (i > 0 && *rowstart == 0) { memcpy(position, oldposition, rowsize*sizeof(agg::int8u)); oldposition = position; position += rowsize; } else { oldposition = position; start += *rowstart * inrowsize; inposition = start; for(j=0,colstart=colstarts;j<cols;j++,position+=4,colstart++) { inposition += *colstart * 4; memcpy(position, inposition, 4*sizeof(agg::int8u)); } } } // Attatch output buffer to output buffer imo->rbufOut = new agg::rendering_buffer; imo->bufferOut = buffer; imo->rbufOut->attach(imo->bufferOut, imo->colsOut, imo->rowsOut, imo->colsOut * imo->BPP); Py_XDECREF(x); Py_XDECREF(y); Py_XDECREF(d); PyMem_Free(rowstarts); PyMem_Free(colstarts); return Py::asObject(imo); }