/* Representation */
static PyObject* PyBlitzArray_repr(PyBlitzArrayObject* o) {
switch (o->ndim) {
case 1:
return
PyString_FromFormat
("%s(%" PY_FORMAT_SIZE_T "d,'%s')",
Py_TYPE(o)->tp_name,
o->shape[0],
PyBlitzArray_TypenumAsString(o->type_num)
);
case 2:
return
PyString_FromFormat
("%s((%" PY_FORMAT_SIZE_T "d,%" PY_FORMAT_SIZE_T "d),'%s')",
Py_TYPE(o)->tp_name,
o->shape[0],
o->shape[1],
PyBlitzArray_TypenumAsString(o->type_num)
);
case 3:
return
PyString_FromFormat
("%s((%" PY_FORMAT_SIZE_T "d,%" PY_FORMAT_SIZE_T "d,%" PY_FORMAT_SIZE_T "d),'%s')",
Py_TYPE(o)->tp_name,
o->shape[0],
o->shape[1],
o->shape[2],
PyBlitzArray_TypenumAsString(o->type_num)
);
case 4:
return
PyString_FromFormat
("%s((%" PY_FORMAT_SIZE_T "d,%" PY_FORMAT_SIZE_T "d,%" PY_FORMAT_SIZE_T "d,%" PY_FORMAT_SIZE_T "d),'%s')",
Py_TYPE(o)->tp_name,
o->shape[0],
o->shape[1],
o->shape[2],
o->shape[3],
PyBlitzArray_TypenumAsString(o->type_num)
);
default:
return
PyString_FromFormat
("[unsupported] %s(@%" PY_FORMAT_SIZE_T "d,'%s') %" PY_FORMAT_SIZE_T "d elements>",
Py_TYPE(o)->tp_name,
o->ndim,
PyBlitzArray_TypenumAsString(o->type_num),
PyBlitzArray_len(o)
);
}
}
/**
* String representation and print out
*/
static PyObject* PyBoostDiscrete_Repr(PyBoostDiscreteObject* self) {
PyObject* probabilities = PyBoostDiscrete_GetProbabilities(self);
if (!probabilities) return 0;
PyObject* prob_str = PYOBJECT_STR(probabilities);
Py_DECREF(probabilities);
if (!prob_str) return 0;
PyObject* retval = PyUnicode_FromFormat(
"%s(dtype='%s' , probabilities=%U)",
Py_TYPE(self)->tp_name,
PyBlitzArray_TypenumAsString(self->type_num),
prob_str
);
Py_DECREF(prob_str);
#if PYTHON_VERSION_HEX < 0x03000000
if (!retval) return 0;
PyObject* tmp = PyObject_Str(retval);
Py_DECREF(retval);
retval = tmp;
#endif
return retval;
}
PyObject* PyBobIpBase_zigzag(PyObject*, PyObject* args, PyObject* kwds) {
BOB_TRY
/* Parses input arguments in a single shot */
char** kwlist = s_zigzag.kwlist();
PyBlitzArrayObject* src = 0;
PyBlitzArrayObject* dst = 0;
PyObject* bf = 0;
if (!PyArg_ParseTupleAndKeywords(args, kwds, "O&O&|O",
kwlist,
&PyBlitzArray_Converter, &src,
&PyBlitzArray_OutputConverter, &dst,
&bf)) return 0;
auto src_ = make_safe(src);
auto dst_ = make_safe(dst);
if (src->type_num != dst->type_num) {
PyErr_Format(PyExc_TypeError, "source and destination arrays must have the same data types (src: `%s' != dst: `%s')",
PyBlitzArray_TypenumAsString(src->type_num),
PyBlitzArray_TypenumAsString(dst->type_num));
return 0;
}
if (src->ndim != 2) {
PyErr_Format(PyExc_TypeError, "source array must have 2 dimensions types (src_given: `%" PY_FORMAT_SIZE_T "d' != src_expected: 2d')", src->ndim);
return 0;
}
if (dst->ndim != 1) {
PyErr_Format(PyExc_TypeError, "destination array must have 1 dimension type (dst_given: `%" PY_FORMAT_SIZE_T "d' != dst_expected: 1d')", dst->ndim);
return 0;
}
switch (src->type_num) {
return inner_zigzag<uint8_t>(src, dst, bf);
case NPY_UINT16:
return inner_zigzag<uint16_t>(src, dst, bf);
case NPY_FLOAT64:
return inner_zigzag<double>(src, dst, bf);
default:
PyErr_Format(PyExc_TypeError, "zigzag from `%s' (%d) is not supported", PyBlitzArray_TypenumAsString(src->type_num), src->type_num);
}
return 0;
BOB_CATCH_FUNCTION("in zigzag", 0)
}
static int double2d_converter(PyObject *o, PyBlitzArrayObject **a) {
if (PyBlitzArray_Converter(o, a) == 0)
return 0;
// in this case, *a is set to a new reference
if ((*a)->type_num != NPY_FLOAT64 || (*a)->ndim != 2) {
PyErr_Format(PyExc_TypeError,
"cannot convert blitz::Array<%s,%" PY_FORMAT_SIZE_T
"d> to a blitz::Array<double,2>",
PyBlitzArray_TypenumAsString((*a)->type_num), (*a)->ndim);
return 0;
}
return 1;
}
static PyObject* PyBobLearnMLPTrainer_setBiasDerivativeOnLayer
(PyBobLearnMLPTrainerObject* self, PyObject* args, PyObject* kwds) {
/* Parses input arguments in a single shot */
static const char* const_kwlist[] = {"array", "layer", 0};
static char** kwlist = const_cast<char**>(const_kwlist);
PyBlitzArrayObject* array = 0;
Py_ssize_t layer = 0;
if (!PyArg_ParseTupleAndKeywords(args, kwds, "O&n", kwlist,
&PyBlitzArray_Converter, &array, &layer)) return 0;
if (array->type_num != NPY_FLOAT64 || array->ndim != 1) {
PyErr_Format(PyExc_TypeError, "`%s.%s' only supports 1D 64-bit float arrays for argument `array' (or any other object coercible to that), but you provided an object with %" PY_FORMAT_SIZE_T "d dimensions and with type `%s' which is not compatible - check your input", Py_TYPE(self)->tp_name, s_set_bias_derivative_str, array->ndim, PyBlitzArray_TypenumAsString(array->type_num));
return 0;
}
try {
self->cxx->setBiasDerivative(*PyBlitzArrayCxx_AsBlitz<double,1>(array), layer);
}
catch (std::exception& ex) {
PyErr_SetString(PyExc_RuntimeError, ex.what());
return 0;
}
catch (...) {
PyErr_Format(PyExc_RuntimeError, "cannot set bias derivative at layer %" PY_FORMAT_SIZE_T "d for `%s': unknown exception caught", layer, Py_TYPE(self)->tp_name);
return 0;
}
Py_RETURN_NONE;
}
static PyObject* PyBlitzArray_getitem(PyBlitzArrayObject* self,
PyObject* item) {
if (PyBob_NumberCheck(item)) {
if (self->ndim != 1) {
PyErr_Format(PyExc_TypeError, "expected tuple for accessing %" PY_FORMAT_SIZE_T "dD array", self->ndim);
return 0;
}
// if you get to this point, the user has passed single number
Py_ssize_t k = PyNumber_AsSsize_t(item, PyExc_IndexError);
return PyBlitzArray_GetItem(self, &k);
}
if (PySequence_Check(item)) {
if (self->ndim != PySequence_Fast_GET_SIZE(item)) {
PyErr_Format(PyExc_TypeError, "expected tuple of size %" PY_FORMAT_SIZE_T "d for accessing %" PY_FORMAT_SIZE_T "dD array", self->ndim, self->ndim);
return 0;
}
// if you get to this point, then the input tuple has the same size
PyBlitzArrayObject shape;
PyBlitzArrayObject* shape_p = &shape;
if (!PyBlitzArray_IndexConverter(item, &shape_p)) return 0;
return PyBlitzArray_GetItem(self, shape.shape);
}
PyErr_Format(PyExc_TypeError, "%s(@%" PY_FORMAT_SIZE_T "d,'%s') indexing requires a single integers (for 1D arrays) or sequences, for any rank size", Py_TYPE(self)->tp_name, self->ndim, PyBlitzArray_TypenumAsString(self->type_num));
return 0;
}
static PyObject* PyBobIpFlandmark_locate(PyBobIpFlandmarkObject* self, PyObject *args, PyObject* kwds) {
BOB_TRY
char** kwlist = s_locate.kwlist();
PyBlitzArrayObject* image;
int bbx[4];
if (!PyArg_ParseTupleAndKeywords(args, kwds, "O&iiii", kwlist, &PyBlitzArray_Converter, &image, &bbx[0], &bbx[1], &bbx[2], &bbx[3])) return 0;
// create bounding box in format (top, left, bottom, right)
bbx[2] += bbx[0] - 1;
bbx[3] += bbx[1] - 1;
auto image_ = make_safe(image);
// check
if (image->type_num != NPY_UINT8 || image->ndim != 2) {
PyErr_Format(PyExc_TypeError, "`%s' input `image' data must be a 2D array with dtype `uint8' (i.e. a gray-scaled image), but you passed a %" PY_FORMAT_SIZE_T "d array with data type `%s'", Py_TYPE(self)->tp_name, image->ndim, PyBlitzArray_TypenumAsString(image->type_num));
return 0;
}
// detect
std::vector<double> detected(2*self->flandmark->data.options.M);
bob::ip::flandmark::flandmark_detect(*PyBlitzArrayCxx_AsBlitz<uint8_t, 2>(image), bbx, self->flandmark, &detected[0]);
// extract landmarks
blitz::Array<double, 2> landmarks(self->flandmark->data.options.M, 2);
for (int k = 0; k < self->flandmark->data.options.M; ++k){
landmarks(k,0) = detected[2*k];
landmarks(k,1) = detected[2*k+1];
}
return PyBlitzArrayCxx_AsNumpy(landmarks);
BOB_CATCH_MEMBER("locate", 0)
};
static PyMethodDef PyBobIpFlandmark_methods[] = {
{
s_locate.name(),
(PyCFunction)PyBobIpFlandmark_locate,
METH_VARARGS|METH_KEYWORDS,
s_locate.doc()
},
{0} /* Sentinel */
};
PyObject* PyBobIpFlandmark_Repr(PyBobIpFlandmarkObject* self) {
/**
* Expected output:
*
* <bob.ip.flandmark(model='...')>
*/
PyObject* retval = PyUnicode_FromFormat("<%s(model='%s')>", Py_TYPE(self)->tp_name, self->filename);
#if PYTHON_VERSION_HEX < 0x03000000
if (!retval) return 0;
PyObject* tmp = PyObject_Str(retval);
Py_DECREF(retval);
retval = tmp;
#endif
return retval;
}
PyObject* PyBobIpBase_lbphs(PyObject*, PyObject* args, PyObject* kwds) {
BOB_TRY
/* Parses input arguments in a single shot */
char** kwlist = s_lbphs.kwlist();
PyBlitzArrayObject* input = 0,* output = 0;
PyBobIpBaseLBPObject* lbp;
blitz::TinyVector<int,2> size, overlap(0,0);
if (!PyArg_ParseTupleAndKeywords(args, kwds, "O&O!(ii)|(ii)O&", kwlist, &PyBlitzArray_Converter, &input, &PyBobIpBaseLBP_Type, &lbp, &size[0], &size[1], &overlap[0], &overlap[1], &PyBlitzArray_OutputConverter, &output)) return 0;
auto input_ = make_safe(input), output_ = make_xsafe(output);
if (input->ndim != 2 || (output && output->ndim != 2)) {
PyErr_Format(PyExc_TypeError, "lbphs images can only be computed from and to 2D arrays");
return 0;
}
if (output && output->type_num != NPY_UINT64){
PyErr_Format(PyExc_TypeError, "lbphs datatype must be uint64");
}
if (!output){
// generate output in the desired shape
auto res = lbphs_shape(input, lbp, size, overlap);
Py_ssize_t osize[] = {res[0], res[1]};
output = (PyBlitzArrayObject*)PyBlitzArray_SimpleNew(NPY_UINT64, 2, osize);
output_ = make_safe(output);
}
switch (input->type_num){
case NPY_UINT8: return lbphs_inner<uint8_t>(input, lbp, size, overlap, output);
case NPY_UINT16: return lbphs_inner<uint16_t>(input, lbp, size, overlap, output);
case NPY_FLOAT64: return lbphs_inner<double>(input, lbp, size, overlap, output);
default:
PyErr_Format(PyExc_TypeError, "lbphs does not work on 'input' images of type %s", PyBlitzArray_TypenumAsString(input->type_num));
}
return 0;
BOB_CATCH_FUNCTION("in lbphs", 0)
}
PyObject* PyBobIpBase_block(PyObject*, PyObject* args, PyObject* kwds) {
BOB_TRY
/* Parses input arguments in a single shot */
char** kwlist = s_block.kwlist();
PyBlitzArrayObject* input = 0,* output = 0;
blitz::TinyVector<int,2> size, overlap(0,0);
PyObject* flat_ = 0;
if (!PyArg_ParseTupleAndKeywords(args, kwds, "O&(ii)|(ii)O&O!", kwlist, &PyBlitzArray_Converter, &input, &size[0], &size[1], &overlap[0], &overlap[1], &PyBlitzArray_OutputConverter, &output, &PyBool_Type, &flat_)) return 0;
auto input_ = make_safe(input), output_ = make_xsafe(output);
bool flat = f(flat_);
if (input->ndim != 2) {
PyErr_Format(PyExc_TypeError, "blocks can only be extracted from and to 2D arrays");
return 0;
}
bool return_out = false;
if (output){
if (output->type_num != input->type_num){
PyErr_Format(PyExc_TypeError, "``input`` and ``output`` must have the same data type");
return 0;
}
if (output->ndim != 3 && output->ndim != 4){
PyErr_Format(PyExc_TypeError, "``output`` must have either three or four dimensions, not %" PY_FORMAT_SIZE_T "d", output->ndim);
return 0;
}
flat = output->ndim == 3;
} else {
return_out = true;
// generate output in the desired shape
if (flat){
auto res = block_shape3(input, size, overlap);
Py_ssize_t osize[] = {res[0], res[1], res[2]};
output = (PyBlitzArrayObject*)PyBlitzArray_SimpleNew(input->type_num, 3, osize);
} else {
auto res = block_shape4(input, size, overlap);
Py_ssize_t osize[] = {res[0], res[1], res[2], res[3]};
output = (PyBlitzArrayObject*)PyBlitzArray_SimpleNew(input->type_num, 4, osize);
}
output_ = make_safe(output);
}
switch (input->type_num){
case NPY_UINT8: if (flat) block_inner<uint8_t,3>(input, size, overlap, output); else block_inner<uint8_t,4>(input, size, overlap, output); break;
case NPY_UINT16: if (flat) block_inner<uint16_t,3>(input, size, overlap, output); else block_inner<uint16_t,4>(input, size, overlap, output); break;
case NPY_FLOAT64: if (flat) block_inner<double,3>(input, size, overlap, output); else block_inner<double,4>(input, size, overlap, output); break;
default:
PyErr_Format(PyExc_TypeError, "block does not work on 'input' images of type %s", PyBlitzArray_TypenumAsString(input->type_num));
}
if (return_out){
return PyBlitzArray_AsNumpyArray(output, 0);
} else
Py_RETURN_NONE;
BOB_CATCH_FUNCTION("in block", 0)
}
PyObject* PyBobIpBase_histogram(PyObject*, PyObject* args, PyObject* kwargs) {
BOB_TRY
char** kwlist1 = s_histogram.kwlist(0);
char** kwlist2 = s_histogram.kwlist(1);
char** kwlist3 = s_histogram.kwlist(2);
char** kwlist4 = s_histogram.kwlist(3);
PyBlitzArrayObject* src = 0,* hist = 0;
PyObject* min_max = 0;
int bins = 0;
auto src_ = make_xsafe(src), hist_ = make_xsafe(hist);
// get the number of command line arguments
Py_ssize_t nargs = (args?PyTuple_Size(args):0) + (kwargs?PyDict_Size(kwargs):0);
switch (nargs){
case 1:{
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O&|i", kwlist1, &PyBlitzArray_Converter, &src, &bins)) return 0;
// get the number of bins
src_ = make_safe(src);
break;
}
case 2:{
PyObject* k = Py_BuildValue("s", kwlist1[1]);
auto k_ = make_safe(k);
if ((args && PyTuple_Size(args) == 2 && PyInt_Check(PyTuple_GET_ITEM(args,1))) || (kwargs && PyDict_Contains(kwargs, k))){
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O&|i", kwlist1, &PyBlitzArray_Converter, &src, &bins)) return 0;
} else {
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O&O&", kwlist2, &PyBlitzArray_Converter, &src, &PyBlitzArray_OutputConverter, &hist)) return 0;
}
src_ = make_safe(src);
hist_ = make_xsafe(hist);
break;
}
case 3:{
// get values for min and max
PyObject* k = Py_BuildValue("s", kwlist3[2]);
auto k_ = make_safe(k);
if ((args && PyTuple_Size(args) == 3 && PyInt_Check(PyTuple_GET_ITEM(args,2))) || (kwargs && PyDict_Contains(kwargs, k))){
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O&Oi", kwlist3, &PyBlitzArray_Converter, &src, &min_max, &bins)) return 0;
} else {
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O&OO&", kwlist4, &PyBlitzArray_Converter, &src, &min_max, &PyBlitzArray_OutputConverter, &hist)) return 0;
}
src_ = make_safe(src);
hist_ = make_xsafe(hist);
break;
}
default:
PyErr_Format(PyExc_ValueError, "'histogram' called with an unsupported number of arguments");
return 0;
}
// check input size
if (src->ndim != 2){
PyErr_Format(PyExc_TypeError, "'histogram' : The input image must be 2D.");
return 0;
}
// allocate the output, if needed
bool return_out = false;
if (!hist){
return_out = true;
// first, get the number of bins
if (!bins){
if (src->type_num == NPY_UINT8) bins = std::numeric_limits<uint8_t>::max() + 1;
else if (src->type_num == NPY_UINT16) bins = std::numeric_limits<uint16_t>::max() + 1;
else {
PyErr_Format(PyExc_TypeError, "'histogram' : The given input data type %s is not supported, when no bin count is specified.", PyBlitzArray_TypenumAsString(src->type_num));
return 0;
}
}
Py_ssize_t n[] = {bins};
hist = reinterpret_cast<PyBlitzArrayObject*>(PyBlitzArray_SimpleNew(NPY_UINT64, 1, n));
hist_ = make_safe(hist);
} else {
if (hist->type_num != NPY_UINT64){
PyErr_Format(PyExc_TypeError, "'histogram' : The given hist data type %s is not supported, only uint64 is allowed.", PyBlitzArray_TypenumAsString(src->type_num));
return 0;
}
}
// now, get the histogram running
bool res = true;
if (min_max){
switch (src->type_num){
case NPY_UINT8: res = inner_histogram<uint8_t, 'B'>(src, hist, min_max); break;
case NPY_UINT16: res = inner_histogram<uint16_t, 'H'>(src, hist, min_max); break;
case NPY_UINT32: res = inner_histogram<uint32_t, 'I'>(src, hist, min_max); break;
case NPY_UINT64: res = inner_histogram<uint64_t, 'K'>(src, hist, min_max); break;
case NPY_INT8: res = inner_histogram<int8_t, 'b'>(src, hist, min_max); break;
case NPY_INT16: res = inner_histogram<int16_t, 'h'>(src, hist, min_max); break;
case NPY_INT32: res = inner_histogram<int32_t, 'i'>(src, hist, min_max); break;
case NPY_INT64: res = inner_histogram<int64_t, 'L'>(src, hist, min_max); break;
case NPY_FLOAT32: res = inner_histogram<float, 'f'>(src, hist, min_max); break;
case NPY_FLOAT64: res = inner_histogram<double, 'd'>(src, hist, min_max); break;
default:
PyErr_Format(PyExc_TypeError, "'histogram' : The given input data type %s is not supported.", PyBlitzArray_TypenumAsString(src->type_num));
return 0;
}
} else {
switch (src->type_num){
case NPY_UINT8: inner_histogram<uint8_t, 'B'>(src, hist); break;
case NPY_UINT16: inner_histogram<uint16_t, 'H'>(src, hist); break;
case NPY_UINT32: inner_histogram<uint32_t, 'I'>(src, hist); break;
case NPY_UINT64: inner_histogram<uint64_t, 'K'>(src, hist); break;
default:
PyErr_Format(PyExc_TypeError, "'histogram' : The given input data type %s is not supported.", PyBlitzArray_TypenumAsString(src->type_num));
return 0;
}
}
if (!res) return 0;
// return the histogram, if wanted
if (return_out){
return PyBlitzArray_AsNumpyArray(hist, 0);
} else {
Py_RETURN_NONE;
}
BOB_CATCH_FUNCTION("in histogram", 0)
}
PyObject* PyBobIpBase_integral(PyObject*, PyObject* args, PyObject* kwds) {
BOB_TRY
/* Parses input arguments in a single shot */
char** kwlist = s_integral.kwlist();
PyBlitzArrayObject* src = 0,* dst = 0,* sqr = 0;
PyObject* azb = 0;
if (!PyArg_ParseTupleAndKeywords(args, kwds, "O&O&|O&O!", kwlist, &PyBlitzArray_Converter, &src, &PyBlitzArray_OutputConverter, &dst, &PyBlitzArray_OutputConverter, &sqr, &PyBool_Type, &azb)) return 0;
auto src_ = make_safe(src), dst_ = make_safe(dst), sqr_ = make_xsafe(sqr);
bool b = azb && PyObject_IsTrue(azb);
if (src->ndim != 2 || dst->ndim != 2 || (sqr && sqr->ndim != 2)) {
PyErr_Format(PyExc_TypeError, "integral images can only be computed from and to 2D arrays");
return 0;
}
if (sqr && dst->type_num != sqr->type_num) {
PyErr_Format(PyExc_TypeError, "'dst' and 'sqr' arrays must have the same data types (dst: `%s' != sqr: `%s')", PyBlitzArray_TypenumAsString(dst->type_num), PyBlitzArray_TypenumAsString(sqr->type_num));
return 0;
}
switch (src->type_num){
case NPY_INT8: return integral_middle<int8_t>(src, dst, sqr, b);
case NPY_INT16: return integral_middle<int16_t>(src, dst, sqr, b);
case NPY_INT32: return integral_middle<int32_t>(src, dst, sqr, b);
case NPY_INT64: return integral_middle<int64_t>(src, dst, sqr, b);
case NPY_UINT8: return integral_middle<uint8_t>(src, dst, sqr, b);
case NPY_UINT16: return integral_middle<uint16_t>(src, dst, sqr, b);
case NPY_UINT32: return integral_middle<uint32_t>(src, dst, sqr, b);
case NPY_UINT64: return integral_middle<uint64_t>(src, dst, sqr, b);
case NPY_FLOAT32: return integral_middle<float>(src, dst, sqr, b);
case NPY_FLOAT64: return integral_middle<double>(src, dst, sqr, b);
default:
PyErr_Format(PyExc_TypeError, "integral does not work on 'src' images of type %s", PyBlitzArray_TypenumAsString(src->type_num));
}
return 0;
BOB_CATCH_FUNCTION("in integral", 0)
}
static inline PyObject* integral_middle(PyBlitzArrayObject* src, PyBlitzArrayObject* dst, PyBlitzArrayObject* sqr, bool b) {
switch (dst->type_num){
case NPY_INT8: return integral_inner<T1,int8_t>(src, dst, sqr, b);
case NPY_INT16: return integral_inner<T1,int16_t>(src, dst, sqr, b);
case NPY_INT32: return integral_inner<T1,int32_t>(src, dst, sqr, b);
case NPY_INT64: return integral_inner<T1,int64_t>(src, dst, sqr, b);
case NPY_UINT8: return integral_inner<T1,uint8_t>(src, dst, sqr, b);
case NPY_UINT16: return integral_inner<T1,uint16_t>(src, dst, sqr, b);
case NPY_UINT32: return integral_inner<T1,uint32_t>(src, dst, sqr, b);
case NPY_UINT64: return integral_inner<T1,uint64_t>(src, dst, sqr, b);
case NPY_FLOAT32: return integral_inner<T1,float>(src, dst, sqr, b);
case NPY_FLOAT64: return integral_inner<T1,double>(src, dst, sqr, b);
default:
PyErr_Format(PyExc_TypeError, "integral does not work on 'dst' images of type %s", PyBlitzArray_TypenumAsString(dst->type_num));
}
return 0;
}
PyObject* PyBobIpBase_gammaCorrection(PyObject*, PyObject* args, PyObject* kwargs) {
BOB_TRY
char** kwlist = s_gammaCorrection.kwlist();
PyBlitzArrayObject* src = 0,* dst = 0;
double gamma;
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O&d|O&", kwlist, &PyBlitzArray_Converter, &src, &gamma, &PyBlitzArray_OutputConverter, &dst)) return 0;
auto src_ = make_safe(src), dst_ = make_xsafe(dst);
// perform some checks
if (src->ndim != 2 || (dst && dst->ndim != 2)){
PyErr_Format(PyExc_ValueError, "'gamma_correction' can be performed on 2D arrays only");
return 0;
}
if (dst){
if (dst->ndim != 2 || dst->type_num != NPY_FLOAT64){
PyErr_Format(PyExc_TypeError, "'gamma_correction': ``dst`` must be a 2D array of type float");
return 0;
}
} else {
dst = (PyBlitzArrayObject*)PyBlitzArray_SimpleNew(NPY_FLOAT64, 2, src->shape);
dst_ = make_safe(dst);
}
switch (src->type_num){
case NPY_UINT8: return inner_gammaCorrection<uint8_t>(src, dst, gamma);
case NPY_UINT16: return inner_gammaCorrection<uint16_t>(src, dst, gamma);
case NPY_FLOAT64: return inner_gammaCorrection<double>(src, dst, gamma);
default:
PyErr_Format(PyExc_ValueError, "'gamma_correction' of %s arrays is currently not supported, only uint8, uint16 or float64 arrays are", PyBlitzArray_TypenumAsString(dst->type_num));
return 0;
}
BOB_CATCH_FUNCTION("in gamma_correction", 0)
}
PyObject* PyBobIpBase_histogramEqualization(PyObject*, PyObject* args, PyObject* kwargs) {
BOB_TRY
char** kwlist1 = s_histogramEqualization.kwlist(0);
char** kwlist2 = s_histogramEqualization.kwlist(1);
PyBlitzArrayObject* src = 0,* dst = 0;
// get the number of command line arguments
Py_ssize_t nargs = (args?PyTuple_Size(args):0) + (kwargs?PyDict_Size(kwargs):0);
switch (nargs){
case 1:{
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O&", kwlist1, &PyBlitzArray_OutputConverter, &src)) return 0;
break;
}
case 2:{
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O&O&", kwlist2, &PyBlitzArray_Converter, &src, &PyBlitzArray_OutputConverter, &dst)) return 0;
break;
}
default:
PyErr_Format(PyExc_ValueError, "'histogram_equalization' called with an unsupported number of arguments");
return 0;
}
auto src_ = make_safe(src), dst_ = make_xsafe(dst);
// perform some checks
if (src->ndim != 2 || (dst && dst->ndim != 2)){
PyErr_Format(PyExc_ValueError, "'histogram_equalization' can be performed on 2D arrays only");
return 0;
}
// in-place
switch (src->type_num){
case NPY_UINT8:{
if (!dst) return inner_histogramEq<uint8_t, uint8_t>(src, src);
switch (dst->type_num){
case NPY_UINT8: return inner_histogramEq<uint8_t, uint8_t>(src, dst);
case NPY_UINT16: return inner_histogramEq<uint8_t, uint16_t>(src, dst);
case NPY_UINT32: return inner_histogramEq<uint8_t, uint32_t>(src, dst);
case NPY_FLOAT32: return inner_histogramEq<uint8_t, float>(src, dst);
case NPY_FLOAT64: return inner_histogramEq<uint8_t, double>(src, dst);
default:
PyErr_Format(PyExc_ValueError, "'histogram_equalization' can be performed to uint8, uint16, uint32, float32 or float64 arrays, but not to %s", PyBlitzArray_TypenumAsString(dst->type_num));
return 0;
}
}
case NPY_UINT16:{
if (!dst) return inner_histogramEq<uint16_t, uint16_t>(src, src);
switch (dst->type_num){
case NPY_UINT8: return inner_histogramEq<uint16_t, uint8_t>(src, dst);
case NPY_UINT16: return inner_histogramEq<uint16_t, uint16_t>(src, dst);
case NPY_UINT32: return inner_histogramEq<uint16_t, uint32_t>(src, dst);
case NPY_FLOAT32: return inner_histogramEq<uint16_t, float>(src, dst);
case NPY_FLOAT64: return inner_histogramEq<uint16_t, double>(src, dst);
default:
PyErr_Format(PyExc_ValueError, "'histogram_equalization' can be performed to uint8, uint16, uint32, float32 or float64 arrays, but not to %s", PyBlitzArray_TypenumAsString(dst->type_num));
return 0;
}
}
default:
PyErr_Format(PyExc_ValueError, "'histogram_equalization' can be performed on uint8 or uint16 images, but not on %s", PyBlitzArray_TypenumAsString(src->type_num));
}
return 0;
BOB_CATCH_FUNCTION("in histogram_equalization", 0)
}
static int PyBobLearnMLPMachine_setBiases (PyBobLearnMLPMachineObject* self,
PyObject* biases, void* /*closure*/) {
if (PyBob_NumberCheck(biases)){
double v = PyFloat_AsDouble(biases);
if (PyErr_Occurred()) return -1;
self->cxx->setBiases(v);
return 0;
}
if (!PyIter_Check(biases) && !PySequence_Check(biases)) {
PyErr_Format(PyExc_TypeError, "setting attribute `biases' of `%s' requires either a float or an iterable, but you passed `%s' which does not implement the iterator protocol", Py_TYPE(self)->tp_name, Py_TYPE(biases)->tp_name);
return -1;
}
/* Checks and converts all entries */
std::vector<blitz::Array<double,1> > biases_seq;
std::vector<boost::shared_ptr<PyBlitzArrayObject>> biases_seq_;
PyObject* iterator = PyObject_GetIter(biases);
if (!iterator) return -1;
auto iterator_ = make_safe(iterator);
while (PyObject* item = PyIter_Next(iterator)) {
auto item_ = make_safe(item);
PyBlitzArrayObject* bz = 0;
if (!PyBlitzArray_Converter(item, &bz)) {
PyErr_Format(PyExc_TypeError, "`%s' could not convert object of type `%s' at position %" PY_FORMAT_SIZE_T "d of input sequence into an array - check your input", Py_TYPE(self)->tp_name, Py_TYPE(item)->tp_name, biases_seq.size());
return -1;
}
if (bz->ndim != 1 || bz->type_num != NPY_FLOAT64) {
PyErr_Format(PyExc_TypeError, "`%s' only supports 1D 64-bit float arrays for attribute `biases' (or any other object coercible to that), but at position %" PY_FORMAT_SIZE_T "d I have found an object with %" PY_FORMAT_SIZE_T "d dimensions and with type `%s' which is not compatible - check your input", Py_TYPE(self)->tp_name, biases_seq.size(), bz->ndim, PyBlitzArray_TypenumAsString(bz->type_num));
Py_DECREF(bz);
return -1;
}
biases_seq_.push_back(make_safe(bz)); ///< prevents data deletion
biases_seq.push_back(*PyBlitzArrayCxx_AsBlitz<double,1>(bz)); ///< only a view!
}
if (PyErr_Occurred()) return -1;
try {
self->cxx->setBiases(biases_seq);
}
catch (std::exception& ex) {
PyErr_SetString(PyExc_RuntimeError, ex.what());
return -1;
}
catch (...) {
PyErr_Format(PyExc_RuntimeError, "cannot reset `biases' of %s: unknown exception caught", Py_TYPE(self)->tp_name);
return -1;
}
return 0;
}