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 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 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 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 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 *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)
}
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 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 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 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 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)
}
static PyObject *ppndf(PyObject *, PyObject *args, PyObject *kwds) {
BOB_TRY
char **kwlist = ppndf_doc.kwlist();
double v;
if (!PyArg_ParseTupleAndKeywords(args, kwds, "d", kwlist, &v))
return 0;
return Py_BuildValue("d", bob::measure::ppndf(v));
BOB_CATCH_FUNCTION("ppndf", 0)
}
static PyObject* PyBobIpGaborSimilarity_similarity(PyBobIpGaborSimilarityObject* self, PyObject* args, PyObject* kwargs) {
BOB_TRY
char** kwlist = similarity_doc.kwlist();
PyBobIpGaborJetObject* jet1,* jet2;
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O!O!", kwlist, &PyBobIpGaborJet_Type, &jet1, &PyBobIpGaborJet_Type, &jet2)) return 0;
double sim = self->cxx->similarity(*jet1->cxx, *jet2->cxx);
return Py_BuildValue("d", sim);
BOB_CATCH_MEMBER("similarity", 0)
}
static PyObject* PyBobIpGaborSimilarity_disparity(PyBobIpGaborSimilarityObject* self, PyObject* args, PyObject* kwargs) {
BOB_TRY
char** kwlist = disparity_doc.kwlist();
PyBobIpGaborJetObject* jet1,* jet2;
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O!O!", kwlist, &PyBobIpGaborJet_Type, &jet1, &PyBobIpGaborJet_Type, &jet2)) return 0;
const auto& disp = self->cxx->disparity(*jet1->cxx, *jet2->cxx);
return Py_BuildValue("(dd)", disp[0], disp[1]);
BOB_CATCH_MEMBER("disparity", 0)
}
static int PyBobLearnEMGMMMachine_init_copy(PyBobLearnEMGMMMachineObject* self, PyObject* args, PyObject* kwargs) {
char** kwlist = GMMMachine_doc.kwlist(1);
PyBobLearnEMGMMMachineObject* tt;
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O!", kwlist, &PyBobLearnEMGMMMachine_Type, &tt)){
GMMMachine_doc.print_usage();
return -1;
}
self->cxx.reset(new bob::learn::em::GMMMachine(*tt->cxx));
return 0;
}
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)
}
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;
}
static int PyBobLearnEMISVMachine_init_isvbase(PyBobLearnEMISVMachineObject* self, PyObject* args, PyObject* kwargs) {
char** kwlist = ISVMachine_doc.kwlist(0);
PyBobLearnEMISVBaseObject* isv_base;
//Here we have to select which keyword argument to read
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O!", kwlist, &PyBobLearnEMISVBase_Type, &isv_base)){
ISVMachine_doc.print_usage();
return -1;
}
self->cxx.reset(new bob::learn::em::ISVMachine(isv_base->cxx));
return 0;
}
static PyObject *rocch2eer(PyObject *, PyObject *args, PyObject *kwds) {
BOB_TRY
static char **kwlist = rocch2eer_doc.kwlist();
PyBlitzArrayObject *p;
if (!PyArg_ParseTupleAndKeywords(args, kwds, "O&", kwlist,
&double2d_converter, &p))
return 0;
auto p_ = make_safe(p);
auto result = bob::measure::rocch2eer(*PyBlitzArrayCxx_AsBlitz<double, 2>(p));
return Py_BuildValue("d", result);
BOB_CATCH_FUNCTION("rocch2eer", 0)
}
static PyObject* PyBobIpGaborSimilarity_shift_phase(PyBobIpGaborSimilarityObject* self, PyObject* args, PyObject* kwargs) {
BOB_TRY
char** kwlist = shift_phase_doc.kwlist();
PyBobIpGaborJetObject* jet,* reference;
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O!O!", kwlist, &PyBobIpGaborJet_Type, &jet, &PyBobIpGaborJet_Type, &reference)) return 0;
// create new jet
PyBobIpGaborJetObject* shifted = reinterpret_cast<PyBobIpGaborJetObject*>(PyBobIpGaborJet_Type.tp_alloc(&PyBobIpGaborJet_Type, 0));
shifted->cxx.reset(new bob::ip::gabor::Jet(jet->cxx->length()));
// shift it
self->cxx->shift_phase(*jet->cxx, *reference->cxx, *shifted->cxx);
// return it
return Py_BuildValue("N", shifted);
BOB_CATCH_MEMBER("shift_phase", 0)
}
static PyObject *correctly_classified_positives(PyObject *, PyObject *args,
PyObject *kwds) {
BOB_TRY
static char **kwlist = correctly_classified_positives_doc.kwlist();
PyBlitzArrayObject *pos;
double threshold;
if (!PyArg_ParseTupleAndKeywords(args, kwds, "O&d", kwlist,
&double1d_converter, &pos, &threshold))
return 0;
// protects acquired resources through this scope
auto pos_ = make_safe(pos);
auto result = bob::measure::correctlyClassifiedPositives(
*PyBlitzArrayCxx_AsBlitz<double, 1>(pos), threshold);
return PyBlitzArrayCxx_AsNumpy(result);
BOB_CATCH_FUNCTION("correctly_classified_positives", 0)
}
static int PyBobLearnEMGMMMachine_init_number(PyBobLearnEMGMMMachineObject* self, PyObject* args, PyObject* kwargs) {
char** kwlist = GMMMachine_doc.kwlist(0);
int n_inputs = 1;
int n_gaussians = 1;
//Parsing the input argments
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "ii", kwlist, &n_gaussians, &n_inputs))
return -1;
if(n_gaussians < 0){
PyErr_Format(PyExc_TypeError, "gaussians argument must be greater than or equal to zero");
return -1;
}
if(n_inputs < 0){
PyErr_Format(PyExc_TypeError, "input argument must be greater than or equal to zero");
return -1;
}
self->cxx.reset(new bob::learn::em::GMMMachine(n_gaussians, n_inputs));
return 0;
}
static PyObject *precision_recall(PyObject *, PyObject *args, PyObject *kwds) {
BOB_TRY
static char **kwlist = precision_recall_doc.kwlist();
PyBlitzArrayObject *neg;
PyBlitzArrayObject *pos;
double threshold;
if (!PyArg_ParseTupleAndKeywords(args, kwds, "O&O&d", kwlist,
&double1d_converter, &neg,
&double1d_converter, &pos, &threshold))
return 0;
// protects acquired resources through this scope
auto neg_ = make_safe(neg);
auto pos_ = make_safe(pos);
auto result = bob::measure::precision_recall(
*PyBlitzArrayCxx_AsBlitz<double, 1>(neg),
*PyBlitzArrayCxx_AsBlitz<double, 1>(pos), threshold);
return Py_BuildValue("dd", result.first, result.second);
BOB_CATCH_FUNCTION("precision_recall", 0)
}
static PyObject *eer_rocch(PyObject *, PyObject *args, PyObject *kwds) {
BOB_TRY
/* Parses input arguments in a single shot */
char **kwlist = eer_rocch_doc.kwlist();
PyBlitzArrayObject *neg;
PyBlitzArrayObject *pos;
if (!PyArg_ParseTupleAndKeywords(args, kwds, "O&O&", kwlist,
&double1d_converter, &neg,
&double1d_converter, &pos))
return 0;
// protects acquired resources through this scope
auto neg_ = make_safe(neg);
auto pos_ = make_safe(pos);
auto result =
bob::measure::eerRocch(*PyBlitzArrayCxx_AsBlitz<double, 1>(neg),
*PyBlitzArrayCxx_AsBlitz<double, 1>(pos));
return Py_BuildValue("d", result);
BOB_CATCH_FUNCTION("eer_rocch", 0)
}
static int PyBobIpGaborGraph_init(PyBobIpGaborGraphObject* self, PyObject* args, PyObject* kwargs) {
BOB_TRY
char** kwlist1 = Graph_doc.kwlist(3);
char** kwlist2 = Graph_doc.kwlist(2);
char** kwlist3 = Graph_doc.kwlist(1);
char** kwlist4 = Graph_doc.kwlist(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: {
// two ways to call with one argument
PyObject* k = Py_BuildValue("s", kwlist1[0]);
auto k_ = make_safe(k);
if (
(kwargs && PyDict_Contains(kwargs, k)) ||
(args && 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::Graph(*hdf5->f));
} else {
PyListObject* list;
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O!", kwlist2, &PyList_Type, &list)) return -1;
std::vector<blitz::TinyVector<int,2>> nodes(PyList_GET_SIZE(list));
Py_ssize_t i = 0;
for (auto nit = nodes.begin(); nit != nodes.end(); ++nit, ++i){
// check that the object inside the list is a two-element int tuple
if (!PyArg_ParseTuple(PyList_GET_ITEM(list, i), "ii", &((*nit)[0]), &((*nit)[1]))){
PyErr_Format(PyExc_TypeError, "%s requires only tuples of two integral positions in the nodes list", Py_TYPE(self)->tp_name);
return -1;
}
}
self->cxx.reset(new bob::ip::gabor::Graph(nodes));
}
break;
}
case 3:{
blitz::TinyVector<int,2> first, last, step;
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "(ii)(ii)(ii)", kwlist3, &first[0], &first[1], &last[0], &last[1], &step[0], &step[1])) return -1;
self->cxx.reset(new bob::ip::gabor::Graph(first, last, step));
}
break;
case 6:{
blitz::TinyVector<int,2> right, left;
int between, along, above, below;
if (!PyArg_ParseTupleAndKeywords(args, kwargs, "(ii)(ii)iiii", kwlist4, &right[0], &right[1], &left[0], &left[1], &between, &along, &above, &below)) return -1;
self->cxx.reset(new bob::ip::gabor::Graph(right, left, between, along, above, below));
}
break;
default:
return -1;
}
return 0;
BOB_CATCH_MEMBER("Graph constructor", -1)
}
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;
}
