static PyObject *f_score(PyObject *, PyObject *args, PyObject *kwds) {
BOB_TRY
static char **kwlist = f_score_doc.kwlist();
PyBlitzArrayObject *neg;
PyBlitzArrayObject *pos;
double threshold;
double weight = 1.0;
if (!PyArg_ParseTupleAndKeywords(
args, kwds, "O&O&d|d", kwlist, &double1d_converter, &neg,
&double1d_converter, &pos, &threshold, &weight))
return 0;
// protects acquired resources through this scope
auto neg_ = make_safe(neg);
auto pos_ = make_safe(pos);
auto result = bob::measure::f_score(*PyBlitzArrayCxx_AsBlitz<double, 1>(neg),
*PyBlitzArrayCxx_AsBlitz<double, 1>(pos),
threshold, weight);
return Py_BuildValue("d", result);
BOB_CATCH_FUNCTION("f_score", 0)
}
static PyObject *min_weighted_error_rate_threshold(PyObject *, PyObject *args,
PyObject *kwds) {
BOB_TRY
char **kwlist = min_weighted_error_rate_threshold_doc.kwlist();
PyBlitzArrayObject *neg;
PyBlitzArrayObject *pos;
double cost;
PyObject *is_sorted = Py_False;
if (!PyArg_ParseTupleAndKeywords(
args, kwds, "O&O&d|O", kwlist, &double1d_converter, &neg,
&double1d_converter, &pos, &cost, &is_sorted))
return 0;
// protects acquired resources through this scope
auto neg_ = make_safe(neg);
auto pos_ = make_safe(pos);
double result = bob::measure::minWeightedErrorRateThreshold(
*PyBlitzArrayCxx_AsBlitz<double, 1>(neg),
*PyBlitzArrayCxx_AsBlitz<double, 1>(pos), cost,
PyObject_IsTrue(is_sorted));
return Py_BuildValue("d", result);
BOB_CATCH_FUNCTION("min_weighted_error_rate_threshold", 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;
}
static PyObject *roc_for_far(PyObject *, PyObject *args, PyObject *kwds) {
BOB_TRY
/* Parses input arguments in a single shot */
char **kwlist = roc_for_far_doc.kwlist();
PyBlitzArrayObject *neg;
PyBlitzArrayObject *pos;
PyBlitzArrayObject *far;
PyObject *is_sorted = Py_False;
if (!PyArg_ParseTupleAndKeywords(
args, kwds, "O&O&O&|O", kwlist, &double1d_converter, &neg,
&double1d_converter, &pos, &double1d_converter, &far, &is_sorted))
return 0;
// protects acquired resources through this scope
auto neg_ = make_safe(neg);
auto pos_ = make_safe(pos);
auto far_ = make_safe(far);
auto result = bob::measure::roc_for_far(
*PyBlitzArrayCxx_AsBlitz<double, 1>(neg),
*PyBlitzArrayCxx_AsBlitz<double, 1>(pos),
*PyBlitzArrayCxx_AsBlitz<double, 1>(far), PyObject_IsTrue(is_sorted));
return PyBlitzArrayCxx_AsNumpy(result);
BOB_CATCH_FUNCTION("roc_for_far", 0)
}
static PyObject *precision_recall_curve(PyObject *, PyObject *args,
PyObject *kwds) {
BOB_TRY
char **kwlist = precision_recall_curve_doc.kwlist();
PyBlitzArrayObject *neg;
PyBlitzArrayObject *pos;
Py_ssize_t n_points;
if (!PyArg_ParseTupleAndKeywords(args, kwds, "O&O&n", kwlist,
&double1d_converter, &neg,
&double1d_converter, &pos, &n_points))
return 0;
// protects acquired resources through this scope
auto neg_ = make_safe(neg);
auto pos_ = make_safe(pos);
auto result = bob::measure::precision_recall_curve(
*PyBlitzArrayCxx_AsBlitz<double, 1>(neg),
*PyBlitzArrayCxx_AsBlitz<double, 1>(pos), n_points);
return PyBlitzArrayCxx_AsNumpy(result);
BOB_CATCH_FUNCTION("precision_recall_curve", 0)
}
static int PyBobIpGaborSimilarity_init(PyBobIpGaborSimilarityObject* self, PyObject* args, PyObject* kwargs) {
BOB_TRY
char** kwlist1 = Similarity_doc.kwlist(1);
char** kwlist2 = Similarity_doc.kwlist(0);
// two ways to call
PyObject* k = Py_BuildValue("s", kwlist1[0]);
auto k_ = make_safe(k);
if (
(kwargs && PyDict_Contains(kwargs, k)) ||
(args && PyTuple_Size(args) == 1 && PyBobIoHDF5File_Check(PyTuple_GetItem(args, 0)))
){
PyBobIoHDF5FileObject* hdf5;
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O&", kwlist1, &PyBobIoHDF5File_Converter, &hdf5)) return -1;
auto hdf5_ = make_safe(hdf5);
self->cxx.reset(new bob::ip::gabor::Similarity(*hdf5->f));
} else {
const char* name = 0;
PyBobIpGaborTransformObject* gwt = 0;
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s|O!", kwlist2, &name, &PyBobIpGaborTransform_Type, &gwt)) return -1;
if (gwt)
self->cxx.reset(new bob::ip::gabor::Similarity(bob::ip::gabor::Similarity::name_to_type(name), gwt->cxx));
else
self->cxx.reset(new bob::ip::gabor::Similarity(bob::ip::gabor::Similarity::name_to_type(name)));
}
return 0;
BOB_CATCH_MEMBER("Similarity constructor", -1)
}
static PyObject *epc(PyObject *, PyObject *args, PyObject *kwds) {
BOB_TRY
/* Parses input arguments in a single shot */
char **kwlist = epc_doc.kwlist();
PyBlitzArrayObject *dev_neg;
PyBlitzArrayObject *dev_pos;
PyBlitzArrayObject *test_neg;
PyBlitzArrayObject *test_pos;
Py_ssize_t n_points;
PyObject *is_sorted = Py_False;
PyObject *thresholds = Py_False;
if (!PyArg_ParseTupleAndKeywords(
args, kwds, "O&O&O&O&n|OO", kwlist, &double1d_converter, &dev_neg,
&double1d_converter, &dev_pos, &double1d_converter, &test_neg,
&double1d_converter, &test_pos, &n_points, &is_sorted, &thresholds))
return 0;
// protects acquired resources through this scope
auto dev_neg_ = make_safe(dev_neg);
auto dev_pos_ = make_safe(dev_pos);
auto test_neg_ = make_safe(test_neg);
auto test_pos_ = make_safe(test_pos);
auto result = bob::measure::epc(*PyBlitzArrayCxx_AsBlitz<double, 1>(dev_neg),
*PyBlitzArrayCxx_AsBlitz<double, 1>(dev_pos),
*PyBlitzArrayCxx_AsBlitz<double, 1>(test_neg),
*PyBlitzArrayCxx_AsBlitz<double, 1>(test_pos),
n_points, PyObject_IsTrue(is_sorted),
PyObject_IsTrue(thresholds));
return PyBlitzArrayCxx_AsNumpy(result);
BOB_CATCH_FUNCTION("epc", 0)
}
static PyObject *frr_threshold(PyObject *, PyObject *args, PyObject *kwds) {
BOB_TRY
char **kwlist = frr_threshold_doc.kwlist();
PyBlitzArrayObject *neg;
PyBlitzArrayObject *pos;
double frr_value = 0.001;
PyObject *is_sorted = Py_False;
if (!PyArg_ParseTupleAndKeywords(
args, kwds, "O&O&|dO", kwlist, &double1d_converter, &neg,
&double1d_converter, &pos, &frr_value, &is_sorted))
return 0;
// protects acquired resources through this scope
auto neg_ = make_safe(neg);
auto pos_ = make_safe(pos);
auto result =
bob::measure::frrThreshold(*PyBlitzArrayCxx_AsBlitz<double, 1>(neg),
*PyBlitzArrayCxx_AsBlitz<double, 1>(pos),
frr_value, PyObject_IsTrue(is_sorted));
return Py_BuildValue("d", result);
BOB_CATCH_FUNCTION("frr_threshold", 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)
}
static int PyBobLearnMLPMachine_setInputDivision (PyBobLearnMLPMachineObject* self,
PyObject* o, void* /*closure*/) {
if (PyBob_NumberCheck(o)) {
double v = PyFloat_AsDouble(o);
if (PyErr_Occurred()) return -1;
self->cxx->setInputDivision(v);
return 0;
}
PyBlitzArrayObject* input_divide = 0;
if (!PyBlitzArray_Converter(o, &input_divide)) return -1;
auto input_divide_ = make_safe(input_divide);
if (input_divide->type_num != NPY_FLOAT64 || input_divide->ndim != 1) {
PyErr_Format(PyExc_TypeError, "`%s' only supports either a single float or 64-bit floats 1D arrays for property array `input_divide'", Py_TYPE(self)->tp_name);
return -1;
}
try {
self->cxx->setInputDivision(*PyBlitzArrayCxx_AsBlitz<double,1>(input_divide));
}
catch (std::exception& ex) {
PyErr_SetString(PyExc_RuntimeError, ex.what());
return -1;
}
catch (...) {
PyErr_Format(PyExc_RuntimeError, "cannot reset `input_divide' of %s: unknown exception caught", Py_TYPE(self)->tp_name);
return -1;
}
return 0;
}
static int PyBobLearnLinearMachine_setInputSubtraction
(PyBobLearnLinearMachineObject* self, PyObject* o, void* /*closure*/) {
PyBlitzArrayObject* input_subtract = 0;
if (!PyBlitzArray_Converter(o, &input_subtract)) return -1;
auto input_subtract_ = make_safe(input_subtract);
if (input_subtract->type_num != NPY_FLOAT64 || input_subtract->ndim != 1) {
PyErr_Format(PyExc_TypeError, "`%s' only supports 64-bit floats 1D arrays for property array `input_subtract'", Py_TYPE(self)->tp_name);
return -1;
}
try {
self->cxx->setInputSubtraction(*PyBlitzArrayCxx_AsBlitz<double,1>(input_subtract));
}
catch (std::exception& ex) {
PyErr_SetString(PyExc_RuntimeError, ex.what());
return -1;
}
catch (...) {
PyErr_Format(PyExc_RuntimeError, "cannot reset `input_subtract' of %s: unknown exception caught", Py_TYPE(self)->tp_name);
return -1;
}
return 0;
}
static int PyBobSpIDCT1D_SetShape
(PyBobSpIDCT1DObject* self, PyObject* o, void* /*closure*/) {
if (!PySequence_Check(o)) {
PyErr_Format(PyExc_TypeError, "`%s' shape can only be set using tuples (or sequences), not `%s'", Py_TYPE(self)->tp_name, Py_TYPE(o)->tp_name);
return -1;
}
PyObject* shape = PySequence_Tuple(o);
auto shape_ = make_safe(shape);
if (PyTuple_GET_SIZE(shape) != 1) {
PyErr_Format(PyExc_RuntimeError, "`%s' shape can only be set using 1-position tuples (or sequences), not an %" PY_FORMAT_SIZE_T "d-position sequence", Py_TYPE(self)->tp_name, PyTuple_GET_SIZE(shape));
return -1;
}
Py_ssize_t len = PyNumber_AsSsize_t(PyTuple_GET_ITEM(shape, 0), PyExc_OverflowError);
if (PyErr_Occurred()) return -1;
try {
self->cxx->setLength(len);
}
catch (std::exception& ex) {
PyErr_SetString(PyExc_RuntimeError, ex.what());
return -1;
}
catch (...) {
PyErr_Format(PyExc_RuntimeError, "cannot reset `shape' of %s: unknown exception caught", Py_TYPE(self)->tp_name);
return -1;
}
return 0;
}
PyObject* PyBobIpBase_blockOutputShape(PyObject*, PyObject* args, PyObject* kwds) {
BOB_TRY
/* Parses input arguments in a single shot */
char** kwlist = s_blockOutputShape.kwlist();
PyBlitzArrayObject* input = 0;
blitz::TinyVector<int,2> size, overlap(0,0);
PyObject* flat_ = 0;
if (!PyArg_ParseTupleAndKeywords(args, kwds, "O&(ii)|(ii)O!", kwlist, &PyBlitzArray_Converter, &input, &size[0], &size[1], &overlap[0], &overlap[1], &PyBool_Type, &flat_)) return 0;
auto input_ = make_safe(input);
if (input->ndim != 2) {
PyErr_Format(PyExc_TypeError, "block shape can only be computed from and to 2D arrays");
return 0;
}
if (f(flat_)){
auto shape = block_shape3(input, size, overlap);
return Py_BuildValue("(iii)", shape[0], shape[1], shape[2]);
} else {
auto shape = block_shape4(input, size, overlap);
return Py_BuildValue("(iiii)", shape[0], shape[1], shape[2], shape[3]);
}
BOB_CATCH_FUNCTION("in block_output_shape", 0)
}
static int PyBobIpBaseMultiscaleRetinex_init(PyBobIpBaseMultiscaleRetinexObject* self, PyObject* args, PyObject* kwargs) {
BOB_TRY
char** kwlist1 = MultiscaleRetinex_doc.kwlist(0);
char** kwlist2 = MultiscaleRetinex_doc.kwlist(1);
// get the number of command line arguments
Py_ssize_t nargs = (args?PyTuple_Size(args):0) + (kwargs?PyDict_Size(kwargs):0);
PyObject* k = Py_BuildValue("s", kwlist2[0]);
auto k_ = make_safe(k);
if (nargs == 1 && ((args && PyTuple_Size(args) == 1 && PyBobIpBaseMultiscaleRetinex_Check(PyTuple_GET_ITEM(args,0))) || (kwargs && PyDict_Contains(kwargs, k)))){
// copy construct
PyBobIpBaseMultiscaleRetinexObject* msrx;
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O!", kwlist2, &PyBobIpBaseMultiscaleRetinex_Type, &msrx)) return -1;
self->cxx.reset(new bob::ip::base::MultiscaleRetinex(*msrx->cxx));
return 0;
}
int scales = 1, size_min = 1, size_step = 1;
double sigma = 2.;
bob::sp::Extrapolation::BorderType border = bob::sp::Extrapolation::Mirror;
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|iiidO&", kwlist1, &scales, &size_min, &size_step, &sigma, &PyBobSpExtrapolationBorder_Converter, &border)){
MultiscaleRetinex_doc.print_usage();
return -1;
}
self->cxx.reset(new bob::ip::base::MultiscaleRetinex(scales, size_min, size_step, sigma, border));
return 0;
BOB_CATCH_MEMBER("cannot create MultiscaleRetinex", -1)
}
static int PyBobIpBaseTanTriggs_init(PyBobIpBaseTanTriggsObject* self, PyObject* args, PyObject* kwargs) {
BOB_TRY
char** kwlist1 = TanTriggs_doc.kwlist(0);
char** kwlist2 = TanTriggs_doc.kwlist(1);
// get the number of command line arguments
Py_ssize_t nargs = (args?PyTuple_Size(args):0) + (kwargs?PyDict_Size(kwargs):0);
PyObject* k = Py_BuildValue("s", kwlist2[0]);
auto k_ = make_safe(k);
if (nargs == 1 && ((args && PyTuple_Size(args) == 1 && PyBobIpBaseTanTriggs_Check(PyTuple_GET_ITEM(args,0))) || (kwargs && PyDict_Contains(kwargs, k)))){
// copy construct
PyBobIpBaseTanTriggsObject* tt;
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O!", kwlist2, &PyBobIpBaseTanTriggs_Type, &tt)) return -1;
self->cxx.reset(new bob::ip::base::TanTriggs(*tt->cxx));
return 0;
}
double gamma = 0.2, sigma0 = 1., sigma1 = 2., threshold = 10., alpha = 0.1;
int radius = 2;
bob::sp::Extrapolation::BorderType border = bob::sp::Extrapolation::Mirror;
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|dddiddO&", kwlist1, &gamma, &sigma0, &sigma1, &radius, &threshold, &alpha, &PyBobSpExtrapolationBorder_Converter, &border)){
TanTriggs_doc.print_usage();
return -1;
}
self->cxx.reset(new bob::ip::base::TanTriggs(gamma, sigma0, sigma1, radius, threshold, alpha, border));
return 0;
BOB_CATCH_MEMBER("cannot create TanTriggs", -1)
}
static int PyBobLearnLinearMachine_setWeights (PyBobLearnLinearMachineObject* self,
PyObject* o, void* /*closure*/) {
PyBlitzArrayObject* weights = 0;
if (!PyBlitzArray_Converter(o, &weights)) return -1;
auto weights_ = make_safe(weights);
if (weights->type_num != NPY_FLOAT64 || weights->ndim != 2) {
PyErr_Format(PyExc_TypeError, "`%s' only supports 64-bit floats 2D arrays for property array `weights'", Py_TYPE(self)->tp_name);
return -1;
}
try {
self->cxx->setWeights(*PyBlitzArrayCxx_AsBlitz<double,2>(weights));
}
catch (std::exception& ex) {
PyErr_SetString(PyExc_RuntimeError, ex.what());
return -1;
}
catch (...) {
PyErr_Format(PyExc_RuntimeError, "cannot reset `weights' of %s: unknown exception caught", Py_TYPE(self)->tp_name);
return -1;
}
return 0;
}
static int PyBobIpFlandmark_init(PyBobIpFlandmarkObject* self, PyObject* args, PyObject* kwds) {
BOB_TRY
/* Parses input arguments in a single shot */
char** kwlist = s_class.kwlist();
const char* model = 0;
if (!PyArg_ParseTupleAndKeywords(args, kwds, "|s", kwlist, &model)) return -1;
if (!model) {
//use what is stored in __default_model__
PyObject* default_model = PyObject_GetAttrString((PyObject*)self, "_default_model");
if (!default_model) {
PyErr_Format(PyExc_RuntimeError, "`%s' needs a model to properly initialize, but the user has not passed one and `_default_model' is not properly set", Py_TYPE(self)->tp_name);
return -1;
}
auto default_model_ = make_safe(default_model);
model = PyString_AS_STRING(default_model);
}
self->flandmark = bob::ip::flandmark::flandmark_init(model);
if (!self->flandmark){
PyErr_Format(PyExc_RuntimeError, "`%s' could not initialize from model file `%s'", Py_TYPE(self)->tp_name, model);
return -1;
}
//flandmark is now initialized, set filename
self->filename = strndup(model, 256);
//all good, flandmark is ready
return 0;
BOB_CATCH_MEMBER("constructor", -1)
}
static int PyBobIpBaseSIFT_init(PyBobIpBaseSIFTObject* self, PyObject* args, PyObject* kwargs) {
BOB_TRY
char** kwlist1 = SIFT_doc.kwlist(0);
char** kwlist2 = SIFT_doc.kwlist(1);
// get the number of command line arguments
Py_ssize_t nargs = (args?PyTuple_Size(args):0) + (kwargs?PyDict_Size(kwargs):0);
PyObject* k = Py_BuildValue("s", kwlist2[0]);
auto k_ = make_safe(k);
if (nargs == 1 && ((args && PyTuple_Size(args) == 1 && PyBobIpBaseSIFT_Check(PyTuple_GET_ITEM(args,0))) || (kwargs && PyDict_Contains(kwargs, k)))){
// copy construct
PyBobIpBaseSIFTObject* sift;
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O!", kwlist2, &PyBobIpBaseSIFT_Type, &sift)) return -1;
self->cxx.reset(new bob::ip::base::SIFT(*sift->cxx));
return 0;
}
blitz::TinyVector<int,2> size;
int scales, octaves, octave_min;
double sigma_n = 0.5, sigma0 = 1.6, contrast = 0.03, edge = 10., norm = 0.2, factor = 4.;
bob::sp::Extrapolation::BorderType border = bob::sp::Extrapolation::Mirror;
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "(ii)iii|ddddddO&", kwlist1, &size[0], &size[1], &scales, &octaves, &octave_min, &sigma_n, &sigma0, &contrast, &edge, &norm, &factor, &PyBobSpExtrapolationBorder_Converter, &border)){
SIFT_doc.print_usage();
return -1;
}
self->cxx.reset(new bob::ip::base::SIFT(size[0], size[1], scales, octaves, octave_min, sigma_n, sigma0, contrast, edge, norm, factor, border));
return 0;
BOB_CATCH_MEMBER("cannot create SIFT", -1)
}
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 PyObject* PyBobLearnMLPTrainer_backwardStep
(PyBobLearnMLPTrainerObject* self, PyObject* args, PyObject* kwds) {
/* Parses input arguments in a single shot */
static const char* const_kwlist[] = {"machine", "input", "target", 0};
static char** kwlist = const_cast<char**>(const_kwlist);
PyBobLearnMLPMachineObject* machine = 0;
PyBlitzArrayObject* input = 0;
PyBlitzArrayObject* target = 0;
if (!PyArg_ParseTupleAndKeywords(args, kwds, "O!O&O&", kwlist,
&PyBobLearnMLPMachine_Type, &machine,
&PyBlitzArray_Converter, &input,
&PyBlitzArray_Converter, &target)) return 0;
auto input_ = make_safe(input);
auto target_ = make_safe(target);
if (input->type_num != NPY_FLOAT64 || input->ndim != 2) {
PyErr_Format(PyExc_TypeError, "`%s' only supports 2D 64-bit float arrays for input array `input'", Py_TYPE(self)->tp_name);
return 0;
}
if (target->type_num != NPY_FLOAT64 || target->ndim != 2) {
PyErr_Format(PyExc_TypeError, "`%s' only supports 2D 64-bit float arrays for input array `target'", Py_TYPE(self)->tp_name);
return 0;
}
try {
self->cxx->backward_step(*machine->cxx,
*PyBlitzArrayCxx_AsBlitz<double,2>(input),
*PyBlitzArrayCxx_AsBlitz<double,2>(target)
);
}
catch (std::exception& ex) {
PyErr_SetString(PyExc_RuntimeError, ex.what());
return 0;
}
catch (...) {
PyErr_Format(PyExc_RuntimeError, "cannot perform backward-step for `%s': unknown exception caught", Py_TYPE(self)->tp_name);
return 0;
}
Py_RETURN_NONE;
}
boost::shared_ptr<void> make_discrete(PyObject* probabilities) {
std::vector<double> cxx_probabilities;
PyObject* iterator = PyObject_GetIter(probabilities);
if (!iterator) return boost::shared_ptr<void>();
auto iterator_ = make_safe(iterator);
while (PyObject* item = PyIter_Next(iterator)) {
auto item_ = make_safe(item);
double v = PyFloat_AsDouble(item);
if (PyErr_Occurred()) return boost::shared_ptr<void>();
cxx_probabilities.push_back(v);
}
return boost::make_shared<bob::core::random::discrete_distribution<T,double>>(cxx_probabilities);
}
/**
* SoX version
*/
static PyObject* py_sox_version() {
PyObject* retval = PyDict_New();
if (!retval) return 0;
auto retval_ = make_safe(retval);
# if defined(SOX_VERSION)
if (std::strlen(SOX_VERSION) && !dict_set(retval, "sox", SOX_VERSION)) return 0;
# endif
return Py_BuildValue("O", retval);
}
static PyObject* PyBobIpGaborSimilarity_save(PyBobIpGaborSimilarityObject* self, PyObject* args, PyObject* kwargs) {
BOB_TRY
// get list of arguments
char** kwlist = save_doc.kwlist();
PyBobIoHDF5FileObject* file;
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O&", kwlist, PyBobIoHDF5File_Converter, &file)) return 0;
auto file_ = make_safe(file);
self->cxx->save(*file->f);
Py_RETURN_NONE;
BOB_CATCH_MEMBER("save", 0)
}
PyObject* PyBobLearnLinearMachine_Repr(PyBobLearnLinearMachineObject* self) {
/**
* Expected output:
*
* <bob.learn.linear.Machine float64@(3, 2) [act: f(z) = tanh(z)]>
*/
static const std::string identity_str = bob::learn::activation::IdentityActivation().str();
auto weights = make_safe(PyBobLearnLinearMachine_getWeights(self, 0));
if (!weights) return 0;
auto dtype = make_safe(PyObject_GetAttrString(weights.get(), "dtype"));
auto dtype_str = make_safe(PYOBJECT_STR(dtype.get()));
auto shape = make_safe(PyObject_GetAttrString(weights.get(), "shape"));
auto shape_str = make_safe(PYOBJECT_STR(shape.get()));
PyObject* retval = 0;
if (self->cxx->getActivation()->str() == identity_str) {
retval = PyUnicode_FromFormat("<%s %U@%U>",
Py_TYPE(self)->tp_name, dtype_str.get(), shape_str.get());
}
else {
retval = PyUnicode_FromFormat("<%s %s@%s [act: %s]>",
Py_TYPE(self)->tp_name, dtype_str.get(), shape_str.get(),
self->cxx->getActivation()->str().c_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_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)
}
PyObject* PyBobLearnMLPMachine_Repr(PyBobLearnMLPMachineObject* self) {
/**
* Expected output:
*
* <bob.learn.mlp.MLP float64@(3, 5, 2) [hidden: f(z) = tanh(z), out: f(z) = * tanh(z)]>
*/
BOB_TRY
auto shape = make_safe(PyBobLearnMLPMachine_getShape(self, NULL));
auto shape_str = make_safe(PYOBJECT_STR(shape.get()));
PyObject* retval = 0;
auto hidden = self->cxx->getHiddenActivation()->str();
auto output = self->cxx->getOutputActivation()->str();
if (hidden == output) {
retval = PyUnicode_FromFormat("<%s @%U [act: %s]>",
Py_TYPE(self)->tp_name, shape_str.get(),
hidden.c_str());
}
else {
retval = PyUnicode_FromFormat("<%s @%U [hidden: %s, out: %s]>",
Py_TYPE(self)->tp_name, shape_str.get(),
hidden.c_str(), output.c_str());
}
#if PYTHON_VERSION_HEX < 0x03000000
if (!retval) return 0;
PyObject* tmp = PyObject_Str(retval);
Py_DECREF(retval);
retval = tmp;
#endif
return retval;
BOB_CATCH_MEMBER("__repr__", 0)
}
static PyObject* create_module (void) {
# if PY_VERSION_HEX >= 0x03000000
PyObject* m = PyModule_Create(&module_definition);
# else
PyObject* m = Py_InitModule3(BOB_EXT_MODULE_NAME, module_methods, module_docstr);
# endif
if (!m) return 0;
auto m_ = make_safe(m); ///< protects against early returns
/* register version numbers and constants */
if (PyModule_AddIntConstant(m, "api", BOB_BLITZ_API_VERSION) < 0) return 0;
if (PyModule_AddStringConstant(m, "module", BOB_EXT_MODULE_VERSION) < 0) return 0;
PyObject* externals = build_version_dictionary();
if (!externals) return 0;
if (PyModule_AddObject(m, "externals", externals) < 0) return 0;
// call bob_blitz_version once to avoid compiler warning
auto _ = make_safe(bob_blitz_version());
return Py_BuildValue("O", m);
}
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)
}
static PyObject* build_version_dictionary() {
PyObject* retval = PyDict_New();
if (!retval) return 0;
auto retval_ = make_safe(retval);
if (!dict_steal(retval, "Blitz++", blitz_version())) return 0;
if (!dict_steal(retval, "Boost", boost_version())) return 0;
if (!dict_steal(retval, "Compiler", compiler_version())) return 0;
if (!dict_steal(retval, "Python", python_version())) return 0;
if (!dict_steal(retval, "NumPy", numpy_version())) return 0;
return Py_BuildValue("O", retval);
}
static int PyBobLearnEMISVMachine_init_hdf5(PyBobLearnEMISVMachineObject* self, PyObject* args, PyObject* kwargs) {
char** kwlist = ISVMachine_doc.kwlist(2);
PyBobIoHDF5FileObject* config = 0;
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O&", kwlist, &PyBobIoHDF5File_Converter, &config)){
ISVMachine_doc.print_usage();
return -1;
}
auto config_ = make_safe(config);
self->cxx.reset(new bob::learn::em::ISVMachine(*(config->f)));
return 0;
}
